Beispiel #1
0
class TestUpdateLink(TestCase):
    def setUp(self):
        super().setUp()
        self.client = Client()

        data = {'title': 'Django', 'url': 'https://github.com/django/django',
                'tags': ['Web Framework', 'Python']}
        resp = self.client.post('/links/', content_type='application/json',
                                data=json.dumps(data))
        self.link = json.loads(resp.content.decode())

    def test_update(self):
        data = {'title': 'Flask', 'url': 'https://github.com/mitsuhiko/flask'}
        pk = self.link['id']

        resp = self.client.patch('/links/{}/'.format(pk),
                                 content_type='application/json',
                                 data=json.dumps(data))

        obj = json.loads(resp.content.decode())

        assert resp.status_code == 202
        assert obj['title'] == data['title']
        assert obj['url'] == data['url']

    def test_update_with_bad_params(self):
        data = {'name': 'Flask'}

        pk = self.link['id']

        resp = self.client.patch('/links/{}/'.format(pk),
                                 content_type='application/json',
                                 data=json.dumps(data))

        assert resp.status_code == 400
Beispiel #2
0
class TestCategoryAPI(TestCase):
    def setUp(self):
        self.client = Client()
        self.client.login(username=create_test_user(password="******"), password="******")

    def test_list(self):
        category = create_test_category()
        self.assertEqual(1, Category.objects.count())

        _, content = _get_json(reverse("category-list"))
        self.assertEqual(1, content["count"])
        self.assertEqual(category.name, content["results"][0]["name"])
        self.assertEqual(category.arxiv_code, content["results"][0]["arxiv_code"])
        self.assertEqual(category.parent, content["results"][0]["parent"])

    def test_post(self):
        """Categories can online be added by openreview (fixtures) itself."""
        response = self.client.post(reverse("category-list"))
        self.assertEqual(response.status_code, 405, "POST should not be allowed (405 = METHOD NOT ALLOWED)")

    def test_put(self):
        response = self.client.put(reverse("category-list"))
        self.assertEqual(response.status_code, 405, "PUT should not be allowed (405 = METHOD NOT ALLOWED)")

    def test_patch(self):
        response = self.client.patch(reverse("category-list"))
        self.assertEqual(response.status_code, 405, "PATCH should not be allowed (405 = METHOD NOT ALLOWED)")

    def test_delete(self):
        response = self.client.patch(reverse("category-list"))
        self.assertEqual(response.status_code, 405, "DELETE should not be allowed (405 = METHOD NOT ALLOWED)")
Beispiel #3
0
    def test__update_entry_by_api(self):
        c = Client()

        # First create
        response_create = c.post('/test/?type=json',{
            "charfield": "test3",
            "numberfield": 10,
            "datefield": "2016-01-01"
        })

        # Then update
        response = c.patch('/test/1/', "{\"charfield\": \"test1\"}", content_type='application/json')

        # Check it was successful
        self.assertEquals(response.status_code, 200)

        # Get test model
        test = [ x for x in self.loader.model_classes if x.__name__ == 'test'][0]
        # Create new entry queryset
        q = test.objects.all().filter(charfield='test1')

        # check if is there only one this record
        self.assertEqual(len(q), 1)

        # check modules fields
        self.assertEqual(q[0].charfield, 'test1')
        self.assertEqual(q[0].numberfield, 10)
        self.assertEqual(q[0].datefield, date(2016, 1, 1))
Beispiel #4
0
class ProjectTestCases(TestCase):
    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def setUp(self):
        self.client = Client()

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_create_project(self):
        u = ElementalUser(password="******", username="******", trusted=True)
        u.save()
        self.client.login(username="******", password="******")
        data = {"data": "fake_testing_data_create", "name": "my_project", "thumbnail": "thumb"}
        response = self.client.post(reverse("api:project-create"), data)
        self.assertEqual(response.status_code, 201)
        try:
            project = Project.objects.get(data="fake_testing_data_create")
        except:
            project = None
        self.assertIsNotNone(project)

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_create_project_fail(self):
        u = ElementalUser(password="******", username="******")
        u.save()
        self.client.login(username="******", password="******")
        data = {"data": "fake_testing_data_create_fail", "name": "my_project", "thumbnail": "thumb"}
        response = self.client.post(reverse("api:project-create"), data)
        self.assertEqual(response.status_code, 403)
        try:
            project = Project.objects.get(data="fake_testing_data_create_fail")
        except:
            project = None
        self.assertIsNone(project)

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_update_project(self):
        u = ElementalUser(password="******", username="******")
        u.save()
        self.client.login(username="******", password="******")
        project = Project(name="name", user=u, data="fake_data")
        project.save()
        data = {"data": "new_data"}
        data = json.dumps(data)
        response = self.client.patch(
            reverse("api:project-data", args=[project.id]), data, content_type="application/json"
        )
        try:
            project = Project.objects.get(data="new_data")
        except:
            project = None
        self.assertIsNotNone(project)
class AutoMakerEndpointTestCase(TestCase):

    def setUp(self):
        self.auto_makers = []
        for i in range(3):
            self.auto_makers.append(factories.AutoMakerFactory())

        self.c = Client()
        self.list_url = reverse('api:automaker-list')

    def test_call_get_on_list_return_all_items(self):
        response = self.c.get(self.list_url)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.json()), 3)

    def test_call_post_must_create_an_item(self):
        data = {'name': 'Gurgel Awesome'}
        response = self.c.post(self.list_url, data=data)

        self.assertEqual(response.status_code, 201)

        models.AutoMaker.objects.get(name=data['name'])

    def test_call_patch_must_update_an_item(self):
        automaker = self.auto_makers[0]

        data = {'name': 'Gurgel Awesome'}

        item_url = reverse('api:automaker-detail', args=[automaker.id])

        response = self.c.patch(item_url, data=json.dumps(data),
                                content_type='application/json')

        self.assertEqual(response.status_code, 200, response.json())
        automaker.refresh_from_db()

        self.assertEqual(automaker.name, 'Gurgel Awesome')

    def test_call_delete_must_delete_an_item(self):
        automaker = self.auto_makers[0]

        item_url = reverse('api:automaker-detail', args=[automaker.id])
        response = self.c.delete(item_url)

        self.assertEquals(response.status_code, 204)

        self.assertIsNone(
            models.AutoMaker.objects.filter(id=automaker.id).first())
Beispiel #6
0
    def test_done(self, client: Client) -> None:
        """Test whether done process works correctly when invoked correctly."""
        client, headers, user = setup_user_client(client)
        submission = create_submission(claimed_by=user)
        create_transcription(submission, user)
        data = {"username": user.username}

        result = client.patch(
            reverse("submission-done", args=[submission.id]),
            json.dumps(data),
            content_type="application/json",
            **headers,
        )

        submission.refresh_from_db()
        assert result.status_code == status.HTTP_201_CREATED
        assert submission.claimed_by == user
        assert submission.completed_by == user
        assert result.json()["original_id"] == submission.original_id
Beispiel #7
0
    def test_approve_param_false(self, client: Client) -> None:
        """Verify that reverting the approval works correctly."""
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3, approved=True)
        assert submission.approved

        data = {"approved": False}

        result = client.patch(reverse("submission-approve",
                                      args=[submission.id]),
                              json.dumps(data),
                              content_type="application/json",
                              **headers)

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_200_OK
        assert not submission.approved
Beispiel #8
0
class AvailableTestCase(TestCase):
    fixtures = ['scooters.json']

    def setUp(self):
        self.base_url = '/api/v1/scooters/available/'
        self.client = Client()

    def test_regular_get_request_works(self):
        resp = self.client.get(self.base_url)
        self.assertEqual(resp.status_code, 200)

        resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20')
        self.assertEqual(len(resp.json()), 1)

    def test_only_get_requests_are_allowed(self):
        resp = self.client.post(self.base_url)
        self.assertEqual(resp.status_code, 405)

        resp = self.client.patch(self.base_url)
        self.assertEqual(resp.status_code, 405)

        resp = self.client.delete(self.base_url)
        self.assertEqual(resp.status_code, 405)

    def test_only_available_scooters_are_returned(self):
        resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20')
        self.assertEqual(len(resp.json()), 1)

        scooter = Scooter.get_scooter_by_id(resp.json()[0]['id'])
        self.assertIsNotNone(scooter)
        scooter.reserve()

        resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20')
        self.assertEqual(len(resp.json()), 0)

    def test_response_has_correct_fields(self):
        resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20')
        fields = list(resp.json()[0].keys())
        self.assertEqual(fields, ['id', 'lat', 'lng'])

    def test_invalid_params(self):
        resp = self.client.get(self.base_url + '?lat=a&lon=1.0&radius=20')
        self.assertEqual(resp.status_code, 422)
Beispiel #9
0
    def test_approve_param_true(self, client: Client) -> None:
        """Verify that approving a submission works with parameters."""
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3)
        assert not submission.removed_from_queue

        data = {"approved": True}

        result = client.patch(reverse("submission-approve",
                                      args=[submission.id]),
                              json.dumps(data),
                              content_type="application/json",
                              **headers)

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_200_OK
        assert submission.approved
Beispiel #10
0
    def test_get_token_after_token_set(self):
        token = models.Game.objects.get(id=1).auth_token
        client = Client()
        response = client.get(reverse("aimmo/game_token", kwargs={"id": 1}))
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(token, response.json()["token"])

        new_token = "aaaaaaaaaaa"
        response = client.patch(
            reverse("aimmo/game_token", kwargs={"id": 1}),
            json.dumps({"token": new_token}),
            content_type="application/json",
        )

        # Token starts as empty, as long as it is empty, we can make more GET requests
        response = client.get(
            reverse("aimmo/game_token", kwargs={"id": 1}), HTTP_GAME_TOKEN=new_token
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
Beispiel #11
0
    def test_patch_updates_category(self, user_client: Client):
        initial_category: Category = CategoryFactory()
        new_category: Category = CategoryFactory(name="Personal")
        initial_content: Content = ContentFactory(category=initial_category)
        data: Dict[str, Any] = {
            "title": "Title2",
            "body": "Body text",
            "category": {"name": new_category.name},
        }

        response = user_client.patch(
            reverse("panel:content_api", kwargs={"pk": str(initial_content.id)}),
            data=data,
            content_type="application/json",
        )

        assert response.status_code == status.HTTP_200_OK, response.content
        assert Content.objects.count() == 1
        assert Content.objects.first().category == new_category
Beispiel #12
0
    def test_update(self):
        client = Client()
        data = {
            'place_type': '테스트타입',
            'metro_region': '테스트광역시',
            'local_region': '테스트구',
            'road_address': '수정테스트로 1',
            'name': '수정테스트'
        }

        response = client.patch('/place/1',
                                json.dumps(data),
                                content_type='application/json')

        self.assertEquals(response.json(), {"message": "PLACE_UPDATED"})
        self.assertEquals(response.status_code, 200)

        self.assertEquals(Place.objects.get(id=1).road_address, '수정테스트로 1')
        self.assertEquals(Place.objects.get(id=1).name, '수정테스트')
    def test_get_patch_user_with_no_userprofile(self):
        u = User(id=23333)
        u.save()
        self.assertEqual(hasattr(u, 'userprofile'), False)

        client = Client()
        tester_login(client=client)
        response = client.get(user_detail_url(23333))
        self.assertEqual(response.status_code, 200)  # 能够正确访问

        response = client.patch(user_detail_url(23333),
                                data={"about": "I'm 23333"},
                                content_type='application/json')
        self.assertEqual(response.status_code, 200)

        u = User.objects.get(id=23333)
        self.assertEqual(hasattr(u, 'userprofile'),
                         True)  # Patch 操作创建了 userProfile
        self.assertEqual(u.userprofile.about, "I'm 23333")
def test_user_token__issued_at_revoke__invalid(create_user, login_user):
    token = "JWT " + login_user
    c = Client(HTTP_AUTHORIZATION=token)

    jwt_revocation_dt = datetime.utcnow() + timedelta(days=1)
    _ = c.patch(
        reverse("users-detail", kwargs={"pk": create_user["id"]}),
        content_type="application/json",
        data=json.dumps(
            {"issued_at": jwt_revocation_dt.strftime('%Y-%m-%d %H:%M:%S%z')}),
    )

    response = c.post(
        reverse("users-token-verify"),
        content_type="application/json",
        data=json.dumps({"token": token}),
    )

    assert response.status_code == status.HTTP_400_BAD_REQUEST
Beispiel #15
0
    def test_change_mylist_name_success(self):
        client = Client()

        headers = {
            'HTTP_Authorization': self.access_token,
            'HTTP_Character': self.character_id
        }

        mylist_id = self.mylist_id

        mylist = {'new_name': '재밌는 노래들'}

        response = client.patch(f'/storage/mylist/{mylist_id}',
                                json.dumps(mylist),
                                content_type='application/json',
                                **headers)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {'MESSAGE': 'SUCCESS'})
def test_authority_not_authorized(francoralite_context):
    url_prefix = francoralite_context.URL_PREFIX
    client = Client()

    # Back (écriture)
    response = client.patch(url_prefix + '/api/authority/1')
    assert response.status_code == 403
    assert response.json().get(
        'detail') == 'You do not have permission to perform this action.'

    # Front (lecture)
    response = client.get(url_prefix + '/authority/edit/1')
    assert response.status_code == 403
    assert _('Accès interdit.') in response.content.decode('utf8')

    # Front (écriture)
    response = client.post(url_prefix + '/authority/edit/1')
    assert response.status_code == 403
    assert _('Accès interdit.') in response.content.decode('utf8')
Beispiel #17
0
class BoardsApiTestCase(TestCase):
    def setUp(self):
        self.client = Client()
        self.test_board = Boards.objects.create(name='test')

    def test_get_board(self):
        response = self.client.get(f'/api/boards/{self.test_board.id}')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json(), {
            'id': self.test_board.id,
            'name': 'test',
            'bg_color': 'cadetblue'
        })

    def test_get_boards_list(self):
        Boards.objects.create(name='test_2')
        response = self.client.get('/api/boards')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.json()), 2)

    def test_create_board(self):
        response = self.client.post('/api/boards', {'name': 'test'})
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.json(), {
            "id": 2,
            "name": "test",
            "bg_color": "cadetblue"
        })

    def test_update_board(self):
        response = self.client.patch(f'/api/boards/{self.test_board.id}', {
            'id': self.test_board.id,
            'name': 'lalka'
        })
        self.assertEqual(response.status_code, 200)
        self.test_board.refresh_from_db()
        self.assertEqual(self.test_board.name, 'lalka')

    def test_delete_board(self):
        response = self.client.delete(f'/api/boards/{self.test_board.id}')
        self.assertEqual(response.status_code, 204)
        self.assertFalse(Boards.objects.filter(id=self.test_board.id).exists())
class CollectionsUnauthorizeEndpointTestCase(StacBaseTestCase):

    def setUp(self):  # pylint: disable=invalid-name
        self.client = Client()
        self.collection_factory = CollectionFactory()
        self.collection = self.collection_factory.create_sample().model
        self.maxDiff = None  # pylint: disable=invalid-name

    def test_unauthorized_collection_put_patch(self):
        # make sure POST fails for anonymous user:
        # a post with the absolute valid minimum
        sample = self.collection_factory.create_sample(sample='collection-2')

        # make sure PUT fails for anonymous user:
        sample = self.collection_factory.create_sample(
            name=self.collection.name, sample='collection-2'
        )
        response = self.client.put(
            f"/{STAC_BASE_V}/collections/{self.collection.name}",
            data=sample.get_json('put'),
            content_type='application/json'
        )
        self.assertStatusCode(401, response, msg="Unauthorized put was permitted.")

        # make sure PATCH fails for anonymous user:
        response = self.client.patch(
            f"/{STAC_BASE_V}/collections/{self.collection.name}",
            data=sample.get_json('patch'),
            content_type='application/json'
        )
        self.assertStatusCode(401, response, msg="Unauthorized patch was permitted.")

    def test_unauthorized_collection_delete(self):
        path = f'/{STAC_BASE_V}/collections/{self.collection.name}'
        response = self.client.delete(path)
        # Collection delete is not implemented (and currently not foreseen).
        # Status code here is 401, as user is unauthorized for write requests.
        # If logged-in, it should be 405, as DELETE for collections is not
        # implemented.
        self.assertStatusCode(
            401, response, msg="unauthorized and unimplemented collection delete was permitted."
        )
Beispiel #19
0
    def test_done_random_checks(
        self,
        client: Client,
        settings: SettingsWrapper,
        probability: float,
        gamma: int,
        message: bool,
        tor_url: [str, None],
        trans_url: [str, None],
    ) -> None:
        """Test whether the random checks for the done process are invoked correctly."""
        # Mock both the gamma property and the random.random function.
        with patch("authentication.models.BlossomUser.gamma",
                   new_callable=PropertyMock) as mock, patch(
                       "api.views.submission._is_returning_transcriber",
                       return_value=False), patch("random.random",
                                                  lambda: probability):
            mock.return_value = gamma
            # Mock the Slack client to catch the sent messages by the function under test.
            slack_client.chat_postMessage = MagicMock()

            client, headers, user = setup_user_client(client)
            submission = create_submission(tor_url=tor_url, claimed_by=user)
            create_transcription(submission, user, url=trans_url)

            result = client.patch(
                reverse("submission-done", args=[submission.id]),
                json.dumps({"username": user.username}),
                content_type="application/json",
                **headers,
            )
            slack_message = (
                f"Please check the following transcription of u/{user.username}: "
                f"{trans_url if trans_url else tor_url}.")
            assert result.status_code == status.HTTP_201_CREATED
            if message:
                assert (call(
                    channel=settings.SLACK_TRANSCRIPTION_CHECK_CHANNEL,
                    text=slack_message,
                ) in slack_client.chat_postMessage.call_args_list)
            else:
                assert slack_client.chat_postMessage.call_count == 0
    def test_wrong_attributes_doesnt_update_and_returns_error(self):
        orm_person = ORMPerson.objects.create(username='******')
        orm_auth_token = ORMAuthToken.objects.create(person=orm_person)
        experience = ORMExperience.objects.create(title='Exp',
                                                  author=orm_person)
        orm_scene = ORMScene.objects.create(title='T',
                                            description='',
                                            latitude=1,
                                            longitude=2,
                                            experience_id=experience.id)

        client = Client()
        auth_headers = {
            'HTTP_AUTHORIZATION':
            'Token {}'.format(orm_auth_token.access_token),
        }
        response = client.patch(
            reverse('scene', args=[orm_scene.id]),
            urllib.parse.urlencode({
                "title": "",
                "description": "Some description",
                "latitude": 0.3,
                "longitude": 1.2,
                "experience_id": experience.id
            }),
            content_type='application/x-www-form-urlencoded',
            **auth_headers)

        assert not ORMScene.objects.filter(
            title='',
            description='Some description',
            latitude=0.3,
            longitude=1.2,
            experience_id=experience.id).exists()
        body = json.loads(response.content)
        assert body == {
            'error': {
                'source': 'title',
                'code': 'wrong_size',
                'message': 'Title must be between 1 and 30 chars'
            }
        }
Beispiel #21
0
    def test_nsfw_no_change(self, client: Client) -> None:
        """Verify that setting a submission NSFW twice doesn't change anything."""
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3, nsfw=True)
        assert submission.nsfw

        data = {}

        result = client.patch(
            reverse("submission-nsfw", args=[submission.id]),
            json.dumps(data),
            content_type="application/json",
            **headers
        )

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_200_OK
        assert submission.nsfw
Beispiel #22
0
class ReaderUpdateViewTestCase(TestCase):
    def setUp(self):
        self.c = Client()

    @patch('Django.readers.views.ReaderUpdateUseCase')
    def test_repository_update(self, mocked_use_case):
        updated_reader = Reader.from_dict({
            'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
            'full_name': 'John Doe',
            'reg_date': '2015-01-01'
        })

        mocked_use_case().execute.return_value = ro.ResponseSuccess(
            updated_reader)
        response = self.c.patch('/readers/1/', {"full_name": "John Doe"})

        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            json.loads(json.dumps(updated_reader, cls=readers.ReaderEncoder)),
            json.loads(response.content.decode('utf-8')))
Beispiel #23
0
def test_update_a_tweet_should_raise_a_401_unauthorized_error():
    c = Client()

    response = c.post(
        reverse("tweets-list"),
        content_type="application/json",
        data=json.dumps({"name": TWEET_NAME, "content": TWEET_CONTENT}),
    )

    assert response.status_code == status.HTTP_201_CREATED

    body = response.json()

    response = c.patch(
        reverse("tweets-detail", kwargs={"pk": body["id"]}),
        content_type="application/json",
        data=json.dumps({"name": TWEET_NAME, "content": TWEET_CONTENT}),
    )

    assert response.status_code == status.HTTP_401_UNAUTHORIZED
Beispiel #24
0
    def test_modifies_and_returns_experience(self):
        orm_experience = ORMExperience.objects.create(title='T',
                                                      description='')

        client = Client()
        response = client.patch(
            reverse('experience', args=[orm_experience.id]),
            urllib.parse.urlencode({"description": "New description"}),
            content_type='application/x-www-form-urlencoded')

        body = json.loads(response.content)
        updated_experience = ORMExperience.objects.get(
            id=orm_experience.id, title='T', description='New description')
        assert updated_experience is not None
        assert body == {
            'id': str(orm_experience.id),
            'title': 'T',
            'description': 'New description',
            'picture': None,
        }
Beispiel #25
0
    def test_nsfw_param_false(self, client: Client) -> None:
        """Verify that marking a submission as NSFW can be reversed."""
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3, nsfw=True)
        assert submission.nsfw

        data = {"nsfw": False}

        result = client.patch(
            reverse("submission-nsfw", args=[submission.id]),
            json.dumps(data),
            content_type="application/json",
            **headers
        )

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_200_OK
        assert not submission.nsfw
Beispiel #26
0
 def send_patch(self, user_string="user_1", do_auth=True, enforce_csrf_checks=False, *args, **kwargs):
     """
     Send a PATCH request to the configured URL endpoint on behalf of the given user.
     :param user_string: The user to send the request as.
     :param do_auth: Whether or not to log the user in if the view requires authentication.
     :param enforce_csrf_checks: Whether or not to enforce CSRF checks in the HTTP client.
     :param args: Positional arguments for client.patch.
     :param kwargs: Keyword arguments for client.patch.
     :return: The HTTP response.
     """
     client = Client(enforce_csrf_checks=enforce_csrf_checks)
     if self.requires_auth and do_auth:
         user = SaFaker.get_user(user_string)
         client.force_login(user)
     return client.patch(
         self.get_url_path(user=user_string),
         data=self.get_patch_data(user=user_string),
         *args,
         **kwargs
     )
Beispiel #27
0
	def test_bulk_update(self):
		client = Client()

		data = [
			{'parameter': Parameter.objects.create(name='a').id, 'user': 1},
			{'parameter': Parameter.objects.create(name='b').id, 'user': 1},
			]

		response = client.post("/answers/", data=json.dumps(data), content_type='application/json')
		results = json.loads(response.content)

		data = [
			{'id': results[0]['id'], 'parameter': Parameter.objects.create(name='a').id, 'user': 1},
			{'id': results[1]['id'], 'parameter': Parameter.objects.create(name='b').id, 'user': 1},
			]

		response = client.patch("/answers/", data=json.dumps(data), content_type='application/json')
		results = json.loads(response.content)

		print results
Beispiel #28
0
    def test_api(self):
        """
        Test HTTP responses for API
        """
        c = Client()

        ## /api/image response codes
        ## get image: OK
        self.assertEqual(
            c.get(f"/api/images/{self.test['image_id']}").status_code, 200)
        ## post, put, patch, image: MethodNotAllowed
        self.assertEqual(
            c.post(f"/api/images/{self.test['image_id']}").status_code, 405)
        self.assertEqual(
            c.put(f"/api/images/{self.test['image_id']}").status_code, 405)
        self.assertEqual(
            c.patch(f"/api/images/{self.test['image_id']}").status_code, 405)
        ## get image-1: NotFound
        self.assertEqual(
            c.get(f"/api/images/{self.test['image_id']-1}").status_code, 404)
    def test_modifies_and_returns_scene(self):
        orm_person = ORMPerson.objects.create(username='******')
        orm_auth_token = ORMAuthToken.objects.create(person=orm_person)
        experience = ORMExperience.objects.create(title='Exp',
                                                  author=orm_person)
        orm_scene = ORMScene.objects.create(title='T',
                                            description='',
                                            latitude=1,
                                            longitude=2,
                                            experience_id=experience.id)

        client = Client()
        auth_headers = {
            'HTTP_AUTHORIZATION':
            'Token {}'.format(orm_auth_token.access_token),
        }
        response = client.patch(
            reverse('scene', args=[orm_scene.id]),
            urllib.parse.urlencode({
                "description": "New description",
                "latitude": 0.3,
                "longitude": 1.2
            }),
            content_type='application/x-www-form-urlencoded',
            **auth_headers)

        body = json.loads(response.content)
        updated_scene = ORMScene.objects.get(id=orm_scene.id,
                                             title='T',
                                             description='New description',
                                             experience_id=experience.id)
        assert updated_scene is not None
        assert body == {
            'id': str(orm_scene.id),
            'title': 'T',
            'description': 'New description',
            'picture': None,
            'latitude': 0.3,
            'longitude': 1.2,
            'experience_id': str(experience.id),
        }
Beispiel #30
0
    def test_remove_reverting_approval(self, client: Client) -> None:
        """Verify that removing the submission reverts an approval."""
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3, approved=True)
        assert not submission.removed_from_queue
        assert submission.approved

        data = {}

        result = client.patch(reverse("submission-remove",
                                      args=[submission.id]),
                              json.dumps(data),
                              content_type="application/json",
                              **headers)

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_200_OK
        assert submission.removed_from_queue
        assert not submission.approved
Beispiel #31
0
    def test_claim_with_other_completed_claim(self, client: Client) -> None:
        """Test whether a user can claim a submission when another claim has been completed.

        The claim limit should not consider submissions that are already completed.
        """
        client, headers, user = setup_user_client(client)
        create_submission(claimed_by=user, completed_by=user)
        submission = create_submission()

        data = {"username": user.username}

        result = client.patch(
            reverse("submission-claim", args=[submission.id]),
            data,
            content_type="application/json",
            **headers,
        )
        submission.refresh_from_db()
        assert result.status_code == status.HTTP_201_CREATED
        assert result.json()["id"] == submission.id
        assert submission.claimed_by == user
Beispiel #32
0
 def test_update_case_system_via_api(self):
     c = Client()
     self.assertEqual(Case.objects.get(id=self.case1.pk).case_name,
                      self.case1.case_name)
     response = c.patch(
         '/api/case/%s/' % self.case1.pk,
         {
             # "role": 1,
             # "task": [
             #     {
             #         "role": 2,
             #         "task_name": "task_via_api_test"
             #     }
             # ],
             "case_name": "case_via_api_test_update",
         },
         content_type='application/json'
     )
     self.assertEqual(response.status_code, 200)
     self.assertEqual(Case.objects.get(id=self.case1.pk).case_name,
                      'case_via_api_test_update')
 def test_patch_with_invalid_value(self):
     field_and_invalid_example = [
         ['id', self.activity.id],
         ['url', 'a' * 10000],
     ]
     client = Client()
     client.force_login(self.superuser)
     id = self.activity.link.first().id
     for field, example in field_and_invalid_example:
         response = client.patch(activity_link_detail_url(id),
                                 data={field: example},
                                 content_type='application/json')
         if field == 'id':
             self.assertEqual(self.activity.link.first().url,
                              'https://uestc-msc.com/')
         else:
             self.assertEqual(response.status_code, 400,
                              f"{field}={example}")  # 返回 400
             response = client.get(activity_link_detail_url(id))
             self.assertNotEqual(response.json()[field],
                                 example)  # GET 的数据并没有被修改
Beispiel #34
0
 def testGetPatchDeleteQuest(self):
     user = User.objects.get(email='*****@*****.**')
     c = Client()
     c.force_login(user)
     respGet = c.get('/api/v1/bases/%s/questions/%s/' %
                     (str(self.base.base_id), str(self.quest0.pk)))
     self.assertEqual(respGet.status_code, 200)
     serializer = QuestionSerializer(self.quest0)
     self.assertEqual(serializer.data, respGet.data)
     respPatch = c.patch('/api/v1/bases/%s/questions/%s/' %
                         (str(self.base.base_id), str(self.quest0.pk)),
                         data=json.dumps({
                             'qtype': 1,
                             'text': 'New Text'
                         }),
                         content_type='application/json')
     self.assertEqual(respPatch.status_code, 200)
     self.assertEqual(respPatch.data['qtype'], 1)
     respDelete = c.delete('/api/v1/bases/%s/questions/%s/' %
                           (str(self.base.base_id), str(self.quest0.pk)))
     self.assertEqual(respDelete.status_code, 204)
    def test_report_already_removed(self, client: Client) -> None:
        """Verify that reporting an already removed submission doesn't do anything."""
        slack_client.chat_postMessage = MagicMock()
        client, headers, user = setup_user_client(client)

        submission = create_submission(id=3, removed_from_queue=True)
        assert submission.removed_from_queue

        data = {"reason": "Violation of ALL the rules"}

        result = client.patch(reverse("submission-report",
                                      args=[submission.id]),
                              json.dumps(data),
                              content_type="application/json",
                              **headers)

        submission.refresh_from_db()

        assert result.status_code == status.HTTP_201_CREATED
        assert submission.removed_from_queue
        assert slack_client.chat_postMessage.call_count == 0
Beispiel #36
0
class BookReturnViewTestCase(TestCase):
    def setUp(self):
        self.c = Client()

    @patch('Django.books.views.BookReturnUseCase')
    def test_repository_return(self, mocked_use_case):
        updated_book = Book.from_dict({'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33',
                                       'title': 'Fahrenheit 451',
                                       'author': 'Ray Bradbury',
                                       'year': 1984,
                                       'language': 'English',
                                       'is_available': True,
                                       'reader': None
                                       })

        mocked_use_case().execute.return_value = ro.ResponseSuccess(updated_book)
        response = self.c.patch('/books/1/', {"reader": None, 'action': 'take'})

        self.assertEqual(response.status_code, 200)
        self.assertEqual(json.loads(json.dumps(updated_book, cls=books.BookEncoder)),
                         json.loads(response.content.decode('utf-8')))
 def test_api_patch_delete(self):
     client = Client()
     response = client.patch(
         "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk),
         content_type='application/json',
         data=json.dumps({
             "aaa": {
                 "value": None,
                 "label": "new label",
                 "type": "bool",
                 }}),
     )
     self.current_jack_dict.pop('aaa')
     response = client.get(
         "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk),
         content_type='application/json',
     )
     self.assertJSONEqual(
         response.content,
         json.dumps(self.current_jack_dict),
     )
 def test_api_patch_overwrite(self):
     client = Client()
     response = client.patch(
         "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk),
         content_type='application/json',
         data=json.dumps({
             "aaa": {
                 "value": "True",
                 "label": "new label",
                 "type": "bool",
                 }}),
     )
     self.current_jack_dict['aaa']['value'] = 'True'
     self.current_jack_dict['aaa']['label'] = 'new label'
     response = client.get(
         "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk),
         content_type='application/json',
     )
     self.assertJSONEqual(
         response.content,
         json.dumps(self.current_jack_dict),
     )
Beispiel #39
0
class RootViewTestCase(CorvidTestCase):

    def setUp(self):
        super().setUpTheme()
        self.client = Client()

    def tearDown(self):
        super().tearDownTheme()

    def test_not_logged_in_redirect(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/login/', response.url)

    def test_logged_in_go_to_home(self):
        self.assertTrue(self.client.login(username=self.admin_user.username,
                                          password=self.admin_password))
        response = self.client.get('/')
        self.assertEqual(response.status_code, 302)
        self.assertIn('/home/', response.url)

    def test_other_response_types_500(self):
        self.assertTrue(self.client.login(username=self.admin_user.username,
                                          password=self.admin_password))
        response = self.client.post('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.put('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.head('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.delete('/')
        self.assertEqual(response.status_code, 500)

        response = self.client.patch('/')
        self.assertEqual(response.status_code, 500)
class TestUserDetailSerializer(unittest.TestCase):

    def setUp(self):
        self.user = User.objects.create_user('test4')
        self.token = Token.objects.get(user=self.user).key
        self.client = Client()

    def test_update(self):
        user_data = {
            'email': '*****@*****.**',
            'first_name': 'test4',
            'last_name': 'test4',
        }
        header = {'HTTP_AUTHORIZATION': 'Token {}'.format(self.token)}
        user_data = encode_multipart('BoUnDaRyStRiNg', user_data)
        content_type = 'multipart/form-data; boundary=BoUnDaRyStRiNg'
        response = self.client.patch(reverse_lazy('user-detail', kwargs={'username': '******'}), user_data,
                                     content_type,
                                     **header)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(User.objects.get(username='******').email, '*****@*****.**')
        self.assertEqual(User.objects.get(username='******').first_name, 'test4')
        self.assertEqual(User.objects.get(username='******').last_name, 'test4')
class VehicleModelEndpointTestCase(TestCase):

    def setUp(self):
        self.vehicle_models = []
        for i in range(3):
            self.vehicle_models.append(factories.VehicleModelFactory())

        self.c = Client()
        self.list_url = reverse('api:vehiclemodel-list')

    def test_get_must_return_list_of_all_models(self):
        response = self.c.get(self.list_url)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 3)

    def test_get_with_automaker_return_correct_list(self):
        model = self.vehicle_models[0]
        url = '{}?auto_maker={}'.format(
            self.list_url, model.auto_maker_id)

        response = self.c.get(url)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]['id'], model.id)

    def test_get_with_type_return_correct_list(self):
        model = self.vehicle_models[0]
        url = '{}?type={}'.format(
            self.list_url, model.model_type)

        response = self.c.get(url)

        expected = set(models.VehicleModel.objects.filter(
            model_type=model.model_type).values_list('id', flat=True))

        result = {i['id'] for i in response.data}

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), len(expected))
        self.assertEqual(result, expected)

    def test_post_must_create_a_vehicle_model(self):
        auto_maker = self.vehicle_models[0].auto_maker
        data = dict(
            name='Corsa',
            year=1997,
            auto_maker=auto_maker.id
        )

        response = self.c.post(self.list_url, data=data)

        self.assertEqual(response.status_code, 201)

        models.VehicleModel.objects.get(name='Corsa',
                                        year=1997,
                                        auto_maker=auto_maker)

    def test_patch_must_edit_a_vehicle_model(self):
        model = self.vehicle_models[0]

        data = dict(name='Celta')

        url = reverse('api:vehiclemodel-detail', args=[model.id])
        response = self.c.patch(url, data=json.dumps(data), content_type='application/json')

        self.assertEqual(response.status_code, 200)

        model.refresh_from_db()
        self.assertEqual(model.name, 'Celta')

    def test_delete_must_remove_a_vehicle(self):
        model = self.vehicle_models[0]
        url = reverse('api:vehiclemodel-detail', args=[model.id])
        response = self.c.delete(url)

        self.assertEqual(response.status_code, 204)

        self.assertIsNone(models.VehicleModel.objects.filter(id=model.id).first())
class IndicatorPeriodDataTestCase(TestCase):
    """Tests the indicator period data REST endpoints."""

    def setUp(self):
        """ Setup a minimal DB for the tests. """

        self.project = Project.objects.create(
            title="REST test project",
        )

        # Create groups
        check_auth_groups(settings.REQUIRED_AUTH_GROUPS)

        # Create organisation
        self.reporting_org = Organisation.objects.create(
            id=1337,
            name="Test REST reporting",
            long_name="Test REST reporting org",
            new_organisation_type=22
        )

        # Create partnership
        self.partnership = Partnership.objects.create(
            project=self.project,
            organisation=self.reporting_org,
            iati_organisation_role=Partnership.IATI_REPORTING_ORGANISATION,
        )

        # Create active user
        self.username = "******"
        self.password = "******"
        self.user = User.objects.create_user(
            username=self.username,
            email="*****@*****.**",
            password=self.password,
        )
        self.user.is_active = True
        self.user.is_admin = True
        self.user.is_superuser = True
        self.user.save()

        # Create employment
        self.employment = Employment.objects.create(
            user=self.user,
            organisation=self.reporting_org,
            is_approved=True,
        )

        self.c = Client(HTTP_HOST=settings.RSR_DOMAIN)
        self.setup_results_framework()

    def tearDown(self):
        Project.objects.all().delete()
        User.objects.all().delete()
        Organisation.objects.all().delete()
        Group.objects.all().delete()

    def _create_new_user(self, group, is_admin=False, is_superuser=False):
        self.username2 = "username2"
        self.password2 = "password2"
        self.user2 = User.objects.create_user(
            username=self.username2,
            password=self.password2,
            email='{}@test.akvo.org'.format(self.username2),
        )
        self.user2.is_active = True
        self.user2.is_admin = is_admin
        self.user2.is_superuser = is_superuser
        self.user2.save()
        group = Group.objects.get(name='M&E Managers')
        employment = Employment.objects.create(
            user=self.user2,
            organisation=self.reporting_org,
            group=group,
            is_approved=True,
        )
        return employment

    def test_create_update(self):
        """Test that posting an update works."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }

        # When
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')

        # Then
        self.assertEqual(201, response.status_code)

    def test_modify_update(self):
        """Test that modifying an update works."""
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        update_url = '/rest/v1/indicator_period_data_framework/{}/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        period_data_id = json.loads(response.content)['id']
        value = "10.00"

        # When
        data.update({'value': value})
        response = self.c.patch(update_url.format(period_data_id),
                                data=json.dumps(data),
                                content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        self.assertEqual(value, json.loads(response.content)['value'])

    def test_create_disaggregated_update(self):
        """Test that creating an update with disaggregation works."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        value = "10.00"
        disaggregations = [{
            'dimension': self.dimension.id,
            'value': value
        }]
        data = {
            'period': self.period.id,
            'user': self.user.id,
            'value': value,
            'disaggregations': disaggregations
        }

        # When
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')

        # Then
        self.assertEqual(201, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(value, content['value'])
        self.assertEqual(1, len(content['disaggregations']))
        self.assertEqual(float(value), float(content['disaggregations'][0]['value']))

    def test_modify_disaggregated_update(self):
        """Test that modifying an update with disaggregation works."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        value = 10
        disaggregations = [{
            'dimension': self.dimension.id,
            'value': value,
            'update': None
        }]
        data = {
            'period': self.period.id,
            'user': self.user.id,
            'value': value,
            'disaggregations': disaggregations
        }

        update_url = '/rest/v1/indicator_period_data_framework/{}/?format=json'
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        update_id = json.loads(response.content)['id']
        new_value = "12.00"

        # When
        disaggregations[0]['value'] = data['value'] = new_value
        response = self.c.patch(update_url.format(update_id),
                                data=json.dumps(data),
                                content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(new_value, content['value'])
        self.assertEqual(1, len(content['disaggregations']))
        self.assertEqual(float(new_value), float(content['disaggregations'][0]['value']))

    def test_draft_update_invisible_to_me_manager(self):
        """Test that draft update is invisible to M&E managers."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        self._create_new_user(group='M&E Managers')

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(0, len(content['results']))

    def test_draft_update_invisible_to_other_project_editors(self):
        """Test that draft update is invisible to other Project Editors."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        self._create_new_user(group='Project Editors')

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(0, len(content['results']))

    def test_draft_update_visible_to_admin(self):
        """Test that draft update is visible to admins."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        content = json.loads(response.content)
        self._create_new_user(group='Project Editors', is_admin=True)
        update = IndicatorPeriodData.objects.get(id=content['id'])

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(1, len(content['results']))
        self.assertEqual(update.id, content['results'][0]['id'])

    def test_period_framework_hides_draft_updates_for_me_managers(self):
        """Test draft updates hidden from M&E Managers in period framework."""
        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        self._create_new_user(group='M&E Managers')

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        url = '/rest/v1/indicator_period_framework/?format=json'
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(0, len(content['results'][0]['data']))

    def test_period_framework_hides_draft_updates_for_project_editors(self):
        """Test draft updates hidden from other Project Editors in period framework."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        self._create_new_user(group='Project Editors')

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        url = '/rest/v1/indicator_period_framework/?format=json'
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(0, len(content['results'][0]['data']))

    def test_period_framework_lists_draft_updates_for_admin(self):
        """Test draft updates visible to admins in the period framework."""

        # Given
        self.c.login(username=self.username, password=self.password)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        content = json.loads(response.content)
        self._create_new_user(group='Project Editors', is_admin=True)
        update = IndicatorPeriodData.objects.get(id=content['id'])

        # When
        self.c.logout()
        self.c.login(username=self.username2, password=self.password2)
        url = '/rest/v1/indicator_period_framework/?format=json'
        response = self.c.get(url, content_type='application/json')

        # Then
        self.assertEqual(200, response.status_code)
        content = json.loads(response.content)
        self.assertEqual(1, len(content['results'][0]['data']))
        self.assertEqual(update.id, content['results'][0]['data'][0]['id'])

    def test_percentage_indicator_allows_edit_update(self):
        # Given
        self._create_new_user(group='M&E Managers')
        self.c.login(username=self.username2, password=self.password2)
        url = '/rest/v1/indicator_period_data_framework/?format=json'
        data = {
            'period': self.period.id,
            'user': self.user.id,
            "value": 150,
            "narrative": "",
            "text": "",
            "status": "D",
            "actual_value": 0,
            "numerator": "3",
            "denominator": "2",
            "disaggregations": [],
        }
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')
        self.assertEqual(201, response.status_code)

        # When
        data['id'] = response.data['id']
        data['numerator'] = '5'
        response = self.c.post(url,
                               data=json.dumps(data),
                               content_type='application/json')

        # Then
        self.assertEqual(201, response.status_code)
        self.assertEqual('5.00', response.data['numerator'])

    def setup_results_framework(self):
        self.result = Result.objects.create(
            title='Result 1',
            project=self.project
        )
        self.indicator = Indicator.objects.create(
            title='Indicator 1',
            result=self.result
        )
        self.dimension = IndicatorDimension.objects.create(
            indicator=self.indicator,
            name='Gender',
            value='Female',
        )
        self.period = IndicatorPeriod.objects.create(
            period_start='2016-01-01',
            period_end='2016-12-31',
            indicator=self.indicator
        )
        self.percentage_indicator = Indicator.objects.create(
            title='Indicator 2',
            result=self.result,
            measure='2',
        )
        self.percentage_period = IndicatorPeriod.objects.create(
            period_start='2016-01-01',
            period_end='2016-12-31',
            indicator=self.percentage_indicator
        )
Beispiel #43
0
class WordlistTest(TestCase):
    wordlist_count = 5
    words_count = 5
    
    def setUp(self):
        self.client = Client()
        self.maxDiff = None
    
    def test_rest(self):
        objects = []
        words = []
        def detailed(i):
            return dict(objects[i], words=words[i])
        
        # Create objects
        for i in range(0, self.wordlist_count):
            name = 'Colors'+str(i)
            resp = self.client.post(reverse('wordlist-list'), dumps(
                             {
                              'name': name,
                              's_lang': 'sl',
                              't_lang': 'tl'
                              }), content_type='application/json')
            self.assertEquals(201, resp.status_code)
            self.assertEquals(i+1, Wordlist.objects.count());
            object = loads(resp.content)
            self.assertIn('id', object)
            self.assertIn('name', object)
            self.assertEquals(object['name'], name)
            objects.append(object)
            words.append([])
            
            # Create words
            for j in range(0, self.words_count):
                word = {
                        'word': 'word'+str(j),
                        'wordlist': object['id'],
                        'translation': 'translation'+str(j)
                        }
                resp = self.client.post(reverse('word-create'), dumps(word), content_type='application/json')
                self.assertEquals(201, resp.status_code)
                self.assertEquals(j+1, Wordlist.objects.get(pk=object['id']).word_set.count());
                data = loads(resp.content)
                self.assertIn('id', data)
                self.assertIn('word', data)
                self.assertIn('wordlist', data)
                self.assertIn('translation', data)
                self.assertEquals(data['word'], word['word'])
                self.assertEquals(data['wordlist'], word['wordlist'])
                self.assertEquals(data['translation'], word['translation'])
                words[i].append(data)

        # List objects
        resp = self.client.get(reverse('wordlist-list'))
        self.assertEquals(200, resp.status_code)
        data = loads(resp.content)
        self.assertListEqual(objects, data)
        
        # Update object
        object = objects[0]
        object['name'] = 'CHANGED'
        resp = self.client.patch(reverse('wordlist-detail', kwargs={'pk': str(object['id'])}), dumps(
                                {
                                 'name': object['name']
                                 }), content_type='application/json')
        self.assertEquals(200, resp.status_code)
        data = loads(resp.content)
        self.assertEquals(Wordlist.objects.get(pk=object['id']).name, object['name'])
        self.assertEquals(object['name'], data['name'])
        
        # Read object
        object = detailed(0)
        resp = self.client.get(reverse('wordlist-detail', kwargs={'pk': str(object['id'])}))
        self.assertEquals(200, resp.status_code)
        data = loads(resp.content)
        self.assertDictEqual(object, data)
        
        # Delete object
        object = objects[0]
        resp = self.client.delete(reverse('wordlist-detail', kwargs={'pk': str(object['id'])}))
        self.assertEquals(200, resp.status_code)
        data = loads(resp.content)
        self.assertRaises(Exception, lambda : Wordlist.objects.get(pk=object['id']))
        self.assertEquals({}, data)
Beispiel #44
0
class ReleaseTest(TestCase):
    def setUp(self):
        self.c = Client()
        self.u1 = {"username": "******", "password": "******"}
        u = User.objects.create_user(**self.u1)
        u.is_superuser = True
        u.save()

    def login(self):
        self.c.login(username=self.u1["username"], password=self.u1["password"])

    def test_create_release(self):
        self.login()
        response = self.c.post(reverse("release-list"), data={
            "version": "1.0.0",
            "download_link": "http://www.baidu.com"
        })
        self.assertEqual(response.status_code, 201, response.data)

    def test_create_release_without_login(self):
        response = self.c.post(reverse("release-list"), data={
            "version": "1.0.0",
            "download_link": "http://www.baidu.com"
        })
        self.assertEqual(response.status_code, 403, response.data)

    def test_get_release(self):
        Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com")
        time.sleep(0.1)
        Release.objects.create(version=u"1.0.1", download_link=u"http://www.baidu.com")
        time.sleep(0.1)
        r2 = Release.objects.create(version=u"1.1.1", download_link=u"http://www.baidu.com")

        response = self.c.get(reverse("release-list"))
        self.assertEqual(response.status_code, 200, response.data)
        self.assertEqual(len(response.data), 3, response.data)
        self.assertEqual(str(response.data[0].get("version")), str(r2.version), response.data)

    def test_update_release(self):
        r = Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com")
        self.login()
        response = self.c.patch(reverse("release-list") + "{}/".format(r.id), content_type="application/json", data = '{\
            "version" : "1.1.0"\
        }')
        self.assertEqual(response.status_code, 200, response.data)
        self.assertEqual(response.data.get("version"), "1.1.0", response.data)

    def test_get_latest_release(self):
        Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com")
        time.sleep(0.1)
        Release.objects.create(version=u"1.0.1", download_link=u"http://www.baidu.com")
        time.sleep(0.1)
        Release.objects.create(version=u"1.1.1", download_link=u"http://www.baidu.com")

        response = self.c.get(reverse("release-latest"))
        self.assertEqual(response.data.get("version"),"1.1.1",response.data)

    def test_log_release_request(self):
        Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com")
        self.c.get(reverse("release-latest"))

        self.assertEqual(UpgradeRequest.objects.count(),1)
        self.assertEqual(UpgradeRequest.objects.all()[0].ip,"127.0.0.1")
Beispiel #45
0
class PostTestCase(TestCase):
    def setUp(self):
        self.server = 'http://127.0.0.1'
        self.email = '*****@*****.**'
        self.password = '******'
        self.username = '******'
        self.user_object = get_user_model().objects.create_user(
                username=self.username,
                email=self.email,
                password=self.password,
                is_active=1,
            )
        # second user
        self.email2 = '*****@*****.**'
        self.password2 = '2123456saasdfasdf'
        self.username2 = '2just_test'
        self.user_object2 = get_user_model().objects.create_user(
                username=self.username2,
                email=self.email2,
                password=self.password2,
                is_active=1
            )
        self.client = Client()
        self.client.force_login(self.user_object)

        # act default value
        self.act_title = 'just a test title'
        self.act_content = 'just a test content, content'
        self.act_thumb_url = '1490031868b2eaff2f9ae1a02ec01108757eb768d81dfc'
        self.act_type = 1
        self.act_object = Act.objects.create(
            user=self.user_object,
            act_title=self.act_title,
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=self.act_type,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )

        # post default vale
        self.post_content = 'just_sample_content'
        self.post_thumb_url = '1457502382959cf00'
        self.post_thumb_width = 500.0
        self.post_thumb_height = 1000.0
        self.post_mime_types = 1
        self.nsfw = 1
        self.post_object = Post.objects.create(
            act=self.act_object,
            user=self.user_object,
            post_content=self.post_content,
            post_thumb_url=self.post_thumb_url,
            post_thumb_width=self.post_thumb_width,
            post_thumb_height=self.post_thumb_height,
            post_mime_types=self.post_mime_types,
            nsfw=self.nsfw,
        )

    def test_create_new_same_post(self):
        response = self.client.post('/api/posts/', {
            'act': self.act_object.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_create_new_post_content_too_long(self):
        post_long_content = "asdflasdfsafsadfjaskdfjasf" + \
                            "askdjfsldjfaskdfjsadfjsdfj" + \
                            "askdjfsldjfaskdfjsadfjsdfj" + \
                            "askdjfsldjfaskdfjsadfjsdfj" + \
                            "askdjfsldjfaskdfjsadfjsdfj" + \
                            "askdjfsldjfaskdfjsadfjsdfj"
        response = self.client.post('/api/posts/', {
            'act': self.act_object.id,
            'post_content': post_long_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 400)

    def test_modify_post(self):
        post_c_content = 'modify_post_content'
        post_c_thumb_url = 'modify_url'
        post_c_thumb_width = 100.0
        post_c_thumb_height = 200.0
        json_data = {
            'act': self.act_object.id,
            'user': self.user_object.id,
            'post_content': post_c_content,
            'post_thumb_url': post_c_thumb_url,
            'post_thumb_width': post_c_thumb_width,
            'post_thumb_height': post_c_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        }
        response = self.client.put(
            '/api/posts/' + str(self.post_object.id) + '/',
            json.dumps(json_data), content_type="application/json")
        self.assertEqual(response.status_code, 200)
        post_object = Post.objects.get(id=self.post_object.id)
        self.assertEqual(post_object.post_content, post_c_content)
        self.assertEqual(post_object.post_thumb_url, post_c_thumb_url)
        self.assertEqual(post_object.post_thumb_width, post_c_thumb_width)
        self.assertEqual(post_object.post_thumb_height, post_c_thumb_height)

    def test_delete_post(self):
        response = self.client.delete(
            '/api/posts/' + str(self.post_object.id) + '/',
            content_type="application/json")
        self.assertEqual(response.status_code, 204)

    def test_modify_post_without_content(self):
        post_c_thumb_url = 'modify_url'
        post_c_thumb_width = 100.0
        post_c_thumb_height = 200.0
        json_data = {
            'act': self.act_object.id,
            'user': self.user_object.id,
            'post_thumb_url': post_c_thumb_url,
            'post_thumb_width': post_c_thumb_width,
            'post_thumb_height': post_c_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        }
        response = self.client.patch(
            '/api/posts/' + str(self.post_object.id) + '/',
            json.dumps(json_data), content_type="application/json")
        self.assertEqual(response.status_code, 200)
        post_object = Post.objects.get(id=self.post_object.id)
        self.assertEqual(post_object.post_content, self.post_content)
        self.assertEqual(post_object.post_thumb_url, post_c_thumb_url)
        self.assertEqual(post_object.post_thumb_width, post_c_thumb_width)
        self.assertEqual(post_object.post_thumb_height, post_c_thumb_height)

    def test_modify_post_without_url(self):
        post_c_content = 'modify_post_content'
        post_c_thumb_width = 100.0
        post_c_thumb_height = 200.0
        json_data = {
            'act': self.act_object.id,
            'user': self.user_object.id,
            'post_content': post_c_content,
            'post_thumb_width': post_c_thumb_width,
            'post_thumb_height': post_c_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        }
        response = self.client.patch(
            '/api/posts/' + str(self.post_object.id) + '/',
            json.dumps(json_data), content_type="application/json")
        self.assertEqual(response.status_code, 200)
        post_object = Post.objects.get(id=self.post_object.id)
        self.assertEqual(post_object.post_content, post_c_content)
        self.assertEqual(post_object.post_thumb_url, self.post_thumb_url)
        self.assertEqual(post_object.post_thumb_width, post_c_thumb_width)
        self.assertEqual(post_object.post_thumb_height, post_c_thumb_height)

    def test_modify_ohter_user_post_failed(self):
        self.client.logout()
        self.client.force_login(self.user_object2)
        post_c_content = 'modify_post_content'
        post_c_thumb_url = 'modify_url'
        post_c_thumb_width = 100.0
        post_c_thumb_height = 200.0
        json_data = {
            'act': self.act_object.id,
            'user': self.user_object.id,
            'post_content': post_c_content,
            'post_thumb_url': post_c_thumb_url,
            'post_thumb_width': post_c_thumb_width,
            'post_thumb_height': post_c_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        }
        response = self.client.put(
            '/api/posts/' + str(self.post_object.id) + '/',
            json.dumps(json_data), content_type="application/json")
        self.assertEqual(response.status_code, 403)

    def test_modify_post_logout_failed(self):
        self.client.logout()
        post_c_content = 'modify_post_content'
        post_c_thumb_url = 'modify_url'
        post_c_thumb_width = 100.0
        post_c_thumb_height = 200.0
        json_data = {
            'act': self.act_object.id,
            'user': self.user_object.id,
            'post_content': post_c_content,
            'post_thumb_url': post_c_thumb_url,
            'post_thumb_width': post_c_thumb_width,
            'post_thumb_height': post_c_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        }
        response = self.client.put(
            '/api/posts/' + str(self.post_object.id) + '/',
            json.dumps(json_data), content_type="application/json")
        self.assertEqual(response.status_code, 403)

    def test_create_new_same_post_logout_failed(self):
        self.client.logout()
        response = self.client.post('/api/posts/', {
            'act': self.act_object.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 403)

    def test_delete_post_logout(self):
        self.client.logout()
        response = self.client.delete(
            '/api/posts/' + str(self.post_object.id) + '/',
            content_type="application/json")
        self.assertEqual(response.status_code, 403)

    def test_other_delete_post_failed(self):
        self.client.logout()
        self.client.force_login(self.user_object2)
        response = self.client.delete(
            '/api/posts/' + str(self.post_object.id) + '/',
            content_type="application/json")
        self.assertEqual(response.status_code, 403)

    def test_admin_delete_post(self):
        self.admin_user = get_user_model().objects.create_user(
            username='******',
            email='*****@*****.**',
            password=self.password,
            is_active=1,
            is_admin=1
            )
        self.client.logout()
        self.client.force_login(self.admin_user)

        response = self.client.delete(
            '/api/posts/' + str(self.post_object.id) + '/',
            content_type="application/json")
        self.assertEqual(response.status_code, 204)

    def test_public_acts_author_can_join(self):
        public_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=2,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object)
        response = self.client.post('/api/posts/', {
            'act': public_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_public_acts_other_can_join(self):
        public_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=2,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object2)
        response = self.client.post('/api/posts/', {
            'act': public_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_group_acts_author_can_join(self):
        group_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=1,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object)
        response = self.client.post('/api/posts/', {
            'act': group_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_group_acts_other_can_join(self):
        group_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=1,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object2)
        response = self.client.post('/api/posts/', {
            'act': group_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_private_acts_author_can_join(self):
        private_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=0,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object)
        response = self.client.post('/api/posts/', {
            'act': private_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 201)

    def test_private_acts_other_join_failed(self):
        private_act = Act.objects.create(
            user=self.user_object,
            act_title='public_act',
            act_content=self.act_content,
            act_thumb_url=self.act_thumb_url,
            act_type=0,
            act_ident=10,
            act_url=self.username + '/' + self.act_title,
            )
        self.client = Client()
        self.client.force_login(self.user_object2)
        response = self.client.post('/api/posts/', {
            'act': private_act.id,
            'post_content': self.post_content,
            'post_thumb_url': self.post_thumb_url,
            'post_thumb_width': self.post_thumb_width,
            'post_thumb_height': self.post_thumb_height,
            'post_mime_types': self.post_mime_types,
            'nsfw': self.nsfw,
        })
        self.assertEqual(response.status_code, 403)
class UserTest(TestCase):

    def setUp(self):
        self.client = Client()
        self.token = Token.objects.get(user=factories.UserFactory())
        self.url = '/api/users/update_details'
        self.user = factories.UserFactory()
        self.new_email = '*****@*****.**'
        self.new_password = '******'
        self.current_password = '******'
        self.user.set_password(self.current_password)
        self.user.save()
        self.reset_password_url = '/api/passwords/reset_password'
        self.reset_password_complete_url = '/api/passwords/reset_password_complete'
        grant_permissions()

    def test_update_email(self):
        data = {
            'id': self.user.id,
            'email': self.new_email,
            'auth': str(self.token),
            'current-password': self.current_password,
        }

        response = self.client.patch(
            path=self.url,
            data=json.dumps(data),
            content_type='application/json',
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token)
        )

        assert_equals(response.status_code, status.HTTP_200_OK)
        assert_not_equals(self.user.email, self.new_email)
        assert_equals(User.objects.get(pk=self.user.id).email, self.new_email)

    def test_update_password(self):
        data = {
            'id': self.user.id,
            'password': self.new_password,
            'auth': str(self.token),
            'current-password': self.current_password,
        }

        response = self.client.patch(
            path=self.url,
            data=json.dumps(data),
            content_type='application/json',
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token)
        )

        assert_equals(response.status_code, status.HTTP_200_OK)
        assert_false(self.user.check_password(self.new_password))
        assert_true(User.objects.get(pk=self.user.id).check_password(self.new_password))

    def test_update_missing_field(self):
        data = {
            'id': self.user.id,
            'username': '******',
            'auth': str(self.token),
        }

        response = self.client.patch(
            path=self.url,
            data=json.dumps(data),
            content_type='application/json',
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token)
        )

        assert_equals(response.status_code, status.HTTP_400_BAD_REQUEST)
        assert_equals(User.objects.get(pk=self.user.id), self.user)

    @patch('api.views.PasswordResetTokenGenerator.make_token')
    def test_reset_password(self, PasswordResetTokenGeneratorMock):
        data = {
            'email': self.user.email,
        }

        PasswordResetTokenGeneratorMock.return_value = 'abc'

        response = self.client.post(
            path=self.reset_password_url,
            data=json.dumps(data),
            content_type='application/json',
        )

        assert_equals(response.status_code, status.HTTP_201_CREATED)
        assert_equals(len(mail.outbox), 1)
        assert_equals(mail.outbox[0].subject, 'Reset Your Password')

        data = {
            'reset_token': 'abc',
            'new_password': self.new_password,
            'password_confirmation': self.new_password,
        }

        response = self.client.post(
            path=self.reset_password_complete_url,
            data=json.dumps(data),
            content_type='application/json'
        )

        assert_equals(response.status_code, status.HTTP_200_OK)
        assert_true(User.objects.get(pk=self.user.id).check_password(self.new_password))
        assert_is_none(cache.get(self.user.email))
Beispiel #47
0
class ApiTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.client = Client()

    def test_api_url(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)

    def test_todos_url(self):
        response = self.client.get('/todos')
        self.assertEqual(response.status_code, 200)

    def test_get_existing_todo(self):
        todo = Todo.objects.create(name="My todo name",
                                   description="This is my description")
        response = self.client.get('/todos/%i' % todo.id)
        self.assertEqual(response.status_code, 200)
        returned_object = json.loads(response.content)
        self.assertEqual(returned_object.get('name'), todo.name)
        self.assertEqual(returned_object.get('description'), todo.description)
        self.assertEqual(returned_object.get('checked'), todo.checked)

    def test_get_todos(self):
        expected_items = 10
        for i in range(0, expected_items):
            Todo.objects.create(name="My todo name",
                                description="This is my description")
        response = self.client.get('/todos')
        content = json.loads(response.content)
        self.assertEqual(int(content.get('count')), expected_items)

    def test_post_todo(self):
        todo_dict = {
            'name': 'My Todo',
            'description': 'My Todo Description',
        }

        response = self.client.post('/todos', todo_dict)
        self.assertEqual(response.status_code, 201)

    def test_delete_todo(self):
        todo = Todo.objects.create(name="My todo name",
                                   description="This is my description")

        response = self.client.delete('/todos/%i' % todo.id)
        self.assertEqual(response.status_code, 204)

    def test_update_todo(self):
        todo = Todo.objects.create(name="My todo name",
                                   description="This is my description")
        todo_new_content = {
            'name': 'New Name',
            'description': 'New Description',
        }
        response = self.client.put('/todos/%i' % todo.id,
                                   data=json.dumps(todo_new_content),
                                   content_type='application/json')
        self.assertEqual(response.status_code, 200)

        new_todo = Todo.objects.get(id=todo.id)
        self.assertEqual(new_todo.name, todo_new_content.get('name'))
        self.assertEqual(new_todo.description,
                         todo_new_content.get('description'))

    def test_check_todo(self):
        todo = Todo.objects.create(name="My todo name",
                                   description="This is my description")
        todo_new_content = {'checked': True}
        response = self.client.patch('/todos/%i' % todo.id,
                                     data=json.dumps(todo_new_content),
                                     content_type='application/json')
        self.assertEqual(response.status_code, 200)

        new_todo = Todo.objects.get(id=todo.id)
        self.assertEqual(new_todo.checked, True)
Beispiel #48
0
def generate_all_emails(request: HttpRequest) -> HttpResponse:
    if not settings.TEST_SUITE:  # nocoverage
        # It's really convenient to automatically inline the email CSS
        # here, since that saves a step when testing out changes to
        # the email CSS.  But we don't run this inside the test suite,
        # because by role, the tests shouldn't be doing a provision-like thing.
        subprocess.check_call(["./tools/inline-email-css"])

    # We import the Django test client inside the view function,
    # because it isn't needed in production elsewhere, and not
    # importing it saves ~50ms of unnecessary manage.py startup time.

    from django.test import Client
    client = Client()

    # write fake data for all variables
    registered_email = "*****@*****.**"
    unregistered_email_1 = "*****@*****.**"
    unregistered_email_2 = "*****@*****.**"
    realm = get_realm("zulip")
    other_realm = Realm.objects.exclude(string_id='zulip').first()
    user = get_user_by_delivery_email(registered_email, realm)
    host_kwargs = {'HTTP_HOST': realm.host}

    # Password reset emails
    # active account in realm
    result = client.post('/accounts/password/reset/', {'email': registered_email}, **host_kwargs)
    assert result.status_code == 302
    # deactivated user
    user.is_active = False
    user.save(update_fields=['is_active'])
    result = client.post('/accounts/password/reset/', {'email': registered_email}, **host_kwargs)
    assert result.status_code == 302
    user.is_active = True
    user.save(update_fields=['is_active'])
    # account on different realm
    result = client.post('/accounts/password/reset/', {'email': registered_email},
                         HTTP_HOST=other_realm.host)
    assert result.status_code == 302
    # no account anywhere
    result = client.post('/accounts/password/reset/', {'email': unregistered_email_1}, **host_kwargs)
    assert result.status_code == 302

    # Confirm account email
    result = client.post('/accounts/home/', {'email': unregistered_email_1}, **host_kwargs)
    assert result.status_code == 302

    # Find account email
    result = client.post('/accounts/find/', {'emails': registered_email}, **host_kwargs)
    assert result.status_code == 302

    # New login email
    logged_in = client.login(dev_auth_username=registered_email, realm=realm)
    assert logged_in

    # New user invite and reminder emails
    result = client.post("/json/invites",
                         {"invitee_emails": unregistered_email_2, "stream": ["Denmark"]},
                         **host_kwargs)
    assert result.status_code == 200

    # Verification for new email
    result = client.patch('/json/settings',
                          urllib.parse.urlencode({'email': '*****@*****.**'}),
                          **host_kwargs)
    assert result.status_code == 200

    # Email change successful
    key = Confirmation.objects.filter(type=Confirmation.EMAIL_CHANGE).latest('id').confirmation_key
    url = confirmation_url(key, realm.host, Confirmation.EMAIL_CHANGE)
    user_profile = get_user_by_delivery_email(registered_email, realm)
    result = client.get(url)
    assert result.status_code == 200

    # Reset the email value so we can run this again
    do_change_user_delivery_email(user_profile, registered_email)

    # Follow up day1 day2 emails for normal user
    enqueue_welcome_emails(user_profile)

    # Follow up day1 day2 emails for admin user
    enqueue_welcome_emails(get_user_by_delivery_email("*****@*****.**", realm), realm_creation=True)

    # Realm reactivation email
    do_send_realm_reactivation_email(realm)

    return redirect(email_page)
class PageTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = factories.UserFactory()
        procedure = factories.ProcedureFactory()
        self.page1 = factories.PageFactory(display_index=0, procedure=procedure)
        self.page2 = factories.PageFactory(display_index=1, procedure=procedure)
        self.page3 = factories.PageFactory(display_index=2, procedure=procedure)
        self.token = Token.objects.get(user=self.user)
        self.partial_bulk_url = "/api/pages/partial_bulk_update/"

    @initialize_permissions
    def test_page_reorder_back(self):
        data = [
            {"id": self.page1.id, "display_index": 1},
            {"id": self.page2.id, "display_index": 0},
            {"id": self.page3.id, "display_index": 2},
        ]

        response_patch = self.client.patch(
            path=self.partial_bulk_url,
            data=json.dumps(data),
            content_type="application/json",
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token),
        )

        assert_equals(response_patch.status_code, status.HTTP_200_OK)
        json_resp = json.loads(response_patch.content)

        for page in json_resp:
            if page["id"] == self.page1.id:
                assert_equals(page["display_index"], 1)
            elif page["id"] == self.page2.id:
                assert_equals(page["display_index"], 0)
            elif page["id"] == self.page3.id:
                assert_equals(page["display_index"], 2)
            else:
                assert_true(False)

    @initialize_permissions
    def test_page_reorder_forward(self):
        data = [
            {"id": self.page1.id, "display_index": 0},
            {"id": self.page2.id, "display_index": 2},
            {"id": self.page3.id, "display_index": 1},
        ]

        response_patch = self.client.patch(
            path=self.partial_bulk_url,
            data=json.dumps(data),
            content_type="application/json",
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token),
        )

        assert_equals(response_patch.status_code, status.HTTP_200_OK)
        json_resp = json.loads(response_patch.content)

        for page in json_resp:
            if page["id"] == self.page1.id:
                assert_equals(page["display_index"], 0)
            elif page["id"] == self.page2.id:
                assert_equals(page["display_index"], 2)
            elif page["id"] == self.page3.id:
                assert_equals(page["display_index"], 1)
            else:
                assert_true(False)

    @initialize_permissions
    def test_page_reorder_blank_data(self):
        data = []

        response_patch = self.client.patch(
            path=self.partial_bulk_url,
            data=json.dumps(data),
            content_type="application/json",
            HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token),
        )

        assert_equals(response_patch.status, status.HTTP_400_BAD_REQUEST)
Beispiel #50
0
class AccountsTestCase(LiveServerTestCase):
    def setUp(self):
        self.userOne = {
            'email': '*****@*****.**',
            'password': '******',
            'first_name': 'FirstNameOne',
            'last_name': 'LastNameOne',
        }
        self.userTwo = {
            'email': '*****@*****.**',
            'password': '******',
            'first_name': 'FirstNameTwo',
            'last_name': 'LastNameTwo',
        }
        self.userThree = {
            'email': '*****@*****.**',
            'password': '******',
            'first_name': 'FirstNameThree',
            'last_name': 'LastNameThree',
        }
        EmailUser.objects.create_superuser('*****@*****.**', 'p')
        self.client.post(reverse('users-list'), self.userOne)
        self.client.post(reverse('users-list'), self.userTwo)
        self.client.post(reverse('users-list'), self.userThree)
        self.user_one = get_user_model().objects.get(
            email=self.userOne['email'])
        self.user_two = get_user_model().objects.get(
            email=self.userTwo['email'])
        self.user_three = get_user_model().objects.get(
            email=self.userThree['email'])
        self.user_admin = get_user_model().objects.get(email='*****@*****.**')
        self.client = Client()

    def get_login(self, email, password):
        self.client.login(email=email, password=password)

    def patch_detail(self, pk, data):
        return self.client.patch(
            reverse('users-detail', args=[pk]),
            data=json.dumps(data),
            content_type='application/json')

    def delete_detail(self, pk):
        return self.client.delete(
            reverse('users-detail', args=[pk]))

    def test_get_list_without_auth(self):
        """
        Declines unauthorized users from getting all users
        """
        response = self.client.get(reverse('users-list'))
        self.assertEqual(response.status_code, 401)

    def test_get_detail_without_auth(self):
        """
        Declines unauthorized users from getting detail user
        """
        response = self.client.get(reverse('users-detail',
                                           args=[self.user_one.id]))
        self.assertEqual(response.status_code, 401)

    def test_get_other_user(self):
        """
        Allows getting other users
        """
        self.get_login(self.userTwo['email'], self.userTwo['password'])
        response = self.client.get(reverse('users-detail',
                                           args=[self.user_one.id]))
        self.assertEqual(response.data['first_name'], 'FirstNameOne')

    def test_get_users(self):
        """
        Allows getting user lists
        """
        self.get_login(self.userTwo['email'], self.userTwo['password'])
        response = self.client.get(reverse('users-list'))
        self.assertEqual(response.status_code, 200)

    def test_edit_other_user(self):
        """
        Declines editing other users
        """
        self.get_login(self.userTwo['email'], self.userTwo['password'])
        response = self.patch_detail(self.user_one.id, {"first_name": "Bill"})
        self.assertEqual(
            response.data,
            {'detail': 'You do not have permission to perform this action.'})

    def test_super_edit_other_user(self):
        """
        Allows superusers to edit other users
        """
        self.get_login('*****@*****.**', 'p')
        response = self.patch_detail(self.user_two.id, {"first_name": "Bill"})
        self.assertEqual(response.data["first_name"], "Bill")

    def test_edit_self(self):
        """
        Allows user to edit themselves
        """
        self.get_login(self.userThree['email'], self.userThree['password'])
        response = self.patch_detail(self.user_three.id, {"first_name": "Bill"})
        self.assertEqual(response.data["first_name"], "Bill")

    def test_edit_status(self):
        """
        Declines editing user status
        """
        self.get_login(self.userThree['email'], self.userThree['password'])
        response = self.patch_detail(self.user_three.id, {"is_developer": True})
        self.assertEqual(response.data['is_developer'], False)
        self.patch_detail(self.user_three.id, {"is_superUser": True})
        response = self.patch_detail(self.user_two.id, {'first_name': 'John'})
        self.assertEqual(
            response.data,
            {'detail': 'You do not have permission to perform this action.'})

    def test_delete_self(self):
        """
        Allows deleting yourself
        """
        self.get_login(self.userThree['email'], self.userThree['password'])
        response = self.delete_detail(self.user_three.id)
        self.assertEqual(response.status_code, 204)

    def test_delete_other(self):
        """
        Declines normal users to delete other users
        """
        self.get_login(self.userThree['email'], self.userThree['password'])
        response = self.delete_detail(self.user_two.id)
        self.assertEqual(
            response.data,
            {'detail': 'You do not have permission to perform this action.'})

    def test_super_delete_other(self):
        """
        Allows superusers to delete other users
        """
        self.get_login('*****@*****.**', 'p')
        response = self.delete_detail(self.user_two.id)
        self.assertEqual(response.status_code, 204)

    def test_create_user(self):
        """
        Allows creation of user without login
        """
        self.userEight = {'email': '*****@*****.**',
                          'password': '******',
                          'first_name': 'FirstName',
                          'last_name': 'LastName', }
        response = self.client.post(reverse('users-list'), self.userEight)
        self.assertEqual(response.status_code, 201)

    def test_create_superuser(self):
        """
        If we try to create a superuser via the API, just create a normal user.
        """
        self.userEight = {'email': '*****@*****.**',
                          'password': '******',
                          'first_name': 'FirstName',
                          'last_name': 'LastName',
                          'is_superuser': True}
        response = self.client.post(reverse('users-list'), self.userEight)
        self.assertEqual(response.status_code, 201)
        self.get_login(self.userEight['email'], self.userEight['password'])
        response = self.patch_detail(self.user_two.id, {'first_name': 'John'})
        self.assertEqual(
            response.data,
            {'detail': 'You do not have permission to perform this action.'})
Beispiel #51
0
class LoadWebserviceTest(TestCase):
    """
    Test the webservice generated by previous unit test.
    """

    def setUp(self):
        # Conf for webservice
        self.app_folder = join(join(settings.DJANGO_ROOT, "apps"),
                               "webservice")
        # Create user, token, permissions and client
        self.user = User.objects.create(username="******", password="******")
        self.token = Token.objects.create(user=self.user, key=b'S3CR3T')
        self.client = Client()
        self.client.login(username='******', password='******')
        # permissions
        content_type = ContentType.objects.get_for_model(WsDjangoSite)
        Permission.objects.create(codename='Can view auth user',
                                  name='Can view auth user',
                                  content_type=content_type)
        self.user.user_permissions = Permission.objects.all()
        self.headers = {'HTTP_AUTHORIZATION': 'Token S3CR3T'}
        # fines permissions
        ct = ContentType.objects.get_by_natural_key("webservice", "djangosite")
        FieldPermission.objects.create(name="id", content_type=ct)
        FieldPermission.objects.create(name="domain", content_type=ct)
        FieldPermission.objects.create(name="name", content_type=ct)
        fields_perms = FieldPermission.objects.all()
        ufp = UserFieldPermissions.objects.create(user=self.user)
        ufp.permissions.add(*fields_perms)

    def test_ws1_post(self):
        response = self.client.post('/webservice/djangosite.json',
                                    data=json.dumps({'id': 2, 'domain': 'mydomain', 'name':'myname'}),
                                    content_type='application/json', **self.headers)
        self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'myname'})

    def test_ws2_get(self):
        response = self.client.get('/webservice/djangosite/2.json',
                                   **self.headers)
        self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name':'myname'})

    def test_ws3_list(self):
        response = self.client.get('/webservice/djangosite.json',
                                   **self.headers)
        self.assertTrue({'id': 2, 'domain': 'mydomain', 'name': 'myname'} in response.data)

    def test_ws4_patch(self):
        response = self.client.patch('/webservice/djangosite/2.json', 
                                     data=json.dumps({'name': 'newname'}),
                                     content_type='application/json', **self.headers)
        self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'newname'})

    def test_ws5_put(self):
        response = self.client.put('/webservice/djangosite/2.json', 
                                   data=json.dumps({'name': 'newname2', 'domain':'mydomain','id':2}),
                                   content_type='application/json', **self.headers)
        self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'newname2'})

    def test_ws6_delete(self):
        self.client.delete('/webservice/djangosite/2.json',
                                   **self.headers)
        response2 = self.client.get('/webservice/djangosite/2.json',
                                   **self.headers)
        self.assertEqual(response2.data, {'error': 'Not found'})
class ProfileTestCase(TestCase):

    def setUp(self):
        self.client = Client()
        # Every test needs access to the request factory.
        self.factory = RequestFactory()
        self.admin = User.objects.create_user(
            username='******', email='*****@*****.**', password='******')
        self.user = User.objects.create_user(
            username='******', email='*****@*****.**', password='******')

        os.environ['RECAPTCHA_TESTING'] = 'True'

    def _login_with_api(self, email, password):
        """
        Perform login attempt using the login service.
        """
        data = {
            'email': email,
            'password': password,
        }
        body = json.dumps(data)
        response = self.client.post(
            reverse("api_dispatch_login", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), data=body, follow=True,
            content_type='application/json')
        return response

    def test_login(self):
        """
        Tests that login service works like a charm.
        """
        # self.client.logout()
        response = self._login_with_api('*****@*****.**', '654321')

        self.assertEqual(response.status_code, 200)
        # print "== response:", response.content
        response_data = json.loads(response.content)

        self.assertEqual(response_data.get('success'), True)

    def test_logout(self):
        """
        Tests that logout service works like a charm.
        """
        self.client.logout()
        loged_in = self.client.login(username='******', password='******')
        self.assertEqual(loged_in, True)
        response = self.client.post(
            reverse("api_dispatch_logout", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), follow=True,
            content_type='application/json')

        self.assertEqual(response.status_code, 200)
        # print response.content
        response_data = json.loads(response.content)
        self.assertEqual(response_data.get('success'), True)

    def test_user_api_detail(self):
        """
        Test user api detail response.
        """
        loged_in = self.client.login(username='******', password='******')
        self.assertEqual(loged_in, True)
        response = self.client.get(
            reverse("api_dispatch_me", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), {'format': 'json'}, follow=True)

        self.assertEqual(response.status_code, 200)
        admin_data = json.loads(response.content)

        self.assertEqual(admin_data.get('username'), 'tester')

        for i in range(TASTYPROFILE_API_THROTTLE):
            response = self.client.get(
                reverse("api_dispatch_me", kwargs={
                    "resource_name": "user",
                    "api_name": "v1",
                }), {'format': 'json'}, follow=True)

        self.assertEqual(response.status_code, 429)

        time.sleep(TASTYPROFILE_API_TIMEFRAME + 1)

        response = self.client.get(
            reverse("api_dispatch_me", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), {'format': 'json'}, follow=True)
        self.assertEqual(response.status_code, 200)
        admin_data = json.loads(response.content)
        self.assertEqual(admin_data.get('username'), 'tester')

    def _register_with_api(self, data):
        """
        Request user registration using REST Api.
        """
        self.client.logout()
        json_data = json.dumps(data)
        os.environ['RECAPTCHA_TESTING'] = 'True'
        response = self.client.post(
            reverse("api_dispatch_list", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), data=json_data,
            content_type='application/json')
        return response

    def test_register(self):
        """
        Test successful user registration and login with that user.
        """
        mail.outbox = []
        response = self._register_with_api({
            'first_name': 'Testy',
            'last_name': 'Testerson',
            'email': '*****@*****.**',
            'password': '******',
            'repeat_password': '******',
            'g-recaptcha-response': 'PASSED',
        })

        print response.content

        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.content, '')

        # Try to login with newly created user.
        response = self._login_with_api('*****@*****.**', 'roman.polansky')
        self.assertEqual(response.status_code, 200)
        response_data = json.loads(response.content)
        self.assertEqual(response_data.get('success'), True)

        response = self.client.get(
            reverse("api_dispatch_me", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), {'format': 'json'}, follow=True)
        self.assertEqual(response.status_code, 200)

    def test_register_errors(self):
        """
        Test errors for void input.
        """
        self.client.logout()
        response = self._register_with_api({})
        # print "== response:", response.content
        self.assertEqual(response.status_code, 400)
        error_data = json.loads(response.content)
        self.assertEqual(type(error_data.get('user')), dict)
        # assert False, set(error_data.get('user').keys())
        self.assertTrue(
            set([
                u'username', u'first_name', u'last_name',
                u'repeat_password', u'captcha',
                u'password', u'email',
            ]).issubset(set(error_data.get('user').keys()))
        )

    def test_user_update(self):
        """
        Test successful profile update.
        """
        loged_in = self.client.login(username='******', password='******')
        data = {
            'first_name': 'Changed',
            'email_alt': '*****@*****.**',
            'state': 'JAL'
        }
        json_data = json.dumps(data)
        response = self.client.patch(
            reverse("api_dispatch_detail", kwargs={
                "resource_name": "user",
                "api_name": "v1",
                "username": "******"
            }), data=json_data,
            content_type='application/json')

        self.assertEqual(response.status_code, 202)
        self.assertEqual(response.content, '')
        user = User.objects.get(username='******')
        self.assertEqual(user.first_name, 'Changed')

    def test_password_reset_invalid_email(self):
        mail.outbox = []
        self.client.logout()
        json_data = json.dumps({
            'email': 'tester@example'
        })
        response = self.client.post(
            reverse('api_dispatch_password_reset', kwargs={
                'resource_name': 'user',
                'api_name': 'v1',
            }), data=json_data, content_type='application/json')
        response_data = json.loads(response.content)
        self.assertEqual(response.status_code, 400)
        self.assertEqual(response_data['success'], 'False')
        error_message = str(response_data['errors']['email'])
        self.assertIn('Enter a valid email address', error_message)

    def test_password_reset(self):
        """
        Test the password reset service.
        """
        mail.outbox = []
        self.client.logout()
        json_data = json.dumps({
            'email': '*****@*****.**'
        })
        UserResource._meta.cache.set('*****@*****.**', False)
        response = self.client.post(
            reverse("api_dispatch_password_reset", kwargs={
                "resource_name": "user",
                "api_name": "v1",
            }), data=json_data, content_type='application/json')
        data = json.loads(response.content)
        self.assertEqual(response.status_code, 200)
        self.assertTrue(data.get('success'))
        # Test that one message has been sent.
        self.assertEqual(len(mail.outbox), 1)
        password_reset_email = mail.outbox[0]

        # Verify that the subject of the first message is correct.
        self.assertEqual(
            password_reset_email.subject,
            u'Password reset on testserver')

        match = re.search(
            r'\?token=%s-%s' % (UIDB36_REGEX, TOKEN_REGEX),
            str(password_reset_email.message()))
        uidb36 = match.group('uidb36')
        token = match.group('token')
        json_data = json.dumps({
            'new_password1': '123456',
            'new_password2': '123456',
        })

        response = self.client.post(
            reverse("api_dispatch_password_reset_confirm", kwargs={
                "resource_name": "user",
                "api_name": "v1",
                "uidb36": uidb36,
                "token": token,
            }),
            data=json_data, content_type='application/json')
        self.assertEqual(response.status_code, 200)
        self.assertTrue(data.get('success'))

        loged_in = self.client.login(username='******', password='******')
        self.assertTrue(loged_in)

    def test_password_change(self):
        """
        Test the password change service.
        """
        # Test unauthenticated request
        self.client.logout()
        json_data = json.dumps({})
        response = self.client.post(
            '/api/v1/user/tester/password-change/', data=json_data,
            content_type='application/json')
        self.assertEqual(response.status_code, 400)

        loged_in = self.client.login(username='******', password='******')
        self.assertTrue(loged_in)
        # Bad data
        json_data = ""
        response = self.client.post(
            reverse("api_dispatch_password_change", kwargs={
                "resource_name": "user",
                "api_name": "v1",
                "username": "******",
            }), data=json_data,
            content_type='application/json')
        self.assertEqual(response.status_code, 400)

        # Test missing parameters
        json_data = ""
        response = self.client.post(
            reverse("api_dispatch_password_change", kwargs={
                "resource_name": "user",
                "api_name": "v1",
                "username": "******",
            }), data=json_data,
            content_type='application/json')
        self.assertEqual(response.status_code, 400)

        json_data = json.dumps({
            'old_password': '******',
            'new_password1': '123456',
            'new_password2': '123456',
        })
        response = self.client.post(
            reverse("api_dispatch_password_change", kwargs={
                "resource_name": "user",
                "api_name": "v1",
                "username": "******",
            }), data=json_data,
            content_type='application/json')
        data = json.loads(response.content)
        self.assertEqual(response.status_code, 200)
        self.assertTrue(data.get('success'))
Beispiel #53
0
class PatchRequests(TestCase):
	fixtures = ['nice_fixture3.json']

	def setUp(self):
		self.client = Client()
		response = self.client.post(AUTH_URL, data=TEST_USER_ALICE_JSON, content_type='application/json')
		self.token = json.loads(response.content)['token']

	# def test_can_make_patch_request_to_post(self):
	# 	payload = {
	# 		"content": "This is some patched content."
	# 	}
	# 	response = self.client.patch(POSTS_URL, data=payload, HTTP_X_AUTHORIZATION=self.token)
	# 	self.assertEqual(response.status_code, 201)

	def test_requires_authorization(self):
		patch_request = self.client.patch(POSTS_URL + '/12345')
		self.assertEqual(patch_request.status_code, 401)

	def test_returns_not_found_on_bad_pk(self):
		patch_request = self.client.patch(POSTS_URL + '/a', HTTP_X_AUTHORIZATION=self.token)
		self.assertIn("{", patch_request.content)
		self.assertEqual(patch_request.status_code, 404)


	def test_can_make_update_to_existing_post(self):
		payload = {
			"content": "This is my sentence. This is my modified sentence. This is a third."
		}
		payload = json.dumps(payload)

		warnings.warn("Patch requests only support json")

		patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json')
		print(patch_request.content)
		self.assertEqual(patch_request.status_code, 201)

	def test_can_merge_with_old_sentences_in_post(self):
		post = Post.objects.get(parent_content_type=ContentType.objects.get(name="blog"),
								parent_id = 1)
		ed = Edition.objects.filter(parent = post)
		sentences = Sentence.objects.filter(edition = ed)

		test_content = ' '.join( [sentences[0].text.value, sentences[1].text.value] )
        
		test_content += ' This is a third unmerged sentence.'

		payload = {
			"content": test_content
		}
		payload = json.dumps(payload)

		warnings.warn("Patch requests only support json")

		patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json')
		self.assertEqual(patch_request.status_code, 201)		
		jres = json.loads(patch_request.content)
		self.assertEqual(jres['number_merged'], 2)

	def test_can_make_revisions_to_post_with_no_merging(self):
		payload = {
			"content": "This is my first sentence. This is the second sentence."
		}
		payload = json.dumps(payload)

		warnings.warn("Patch requests only support json")

		patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json')
		self.assertEqual(patch_request.status_code, 201)		
		jres = json.loads(patch_request.content)
		self.assertEqual(jres['number_merged'], 0)
		self.assertEqual(jres['number_sentences'], 2)
Beispiel #54
0
 def test_device_patch_by_id_invalid_payload(self):
     switch = self.createTestSwitch()
     client = Client()
     response = client.patch("/api/devices/1", "invalid patch document")
     self.assertEqual(response.status_code, 400)
Beispiel #55
0
class ProjectTestCases(TestCase):

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def setUp(self):
        self.client = Client()

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_create_project(self):
        u = ElementalUser(password='******',
                          username='******',
                          can_share_projects=True)
        u.save()
        self.client.login(username='******', password='******')
        data = {
            'data': 'fake_testing_data_create',
            'name': 'my_project'
        }
        response = self.client.post(reverse('api:project-create'), data)
        self.assertEqual(response.status_code, 201)
        try:
            project = Project.objects.get(data='fake_testing_data_create')
        except:
            project = None
        self.assertIsNotNone(project)

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_create_project_fail(self):
        u = ElementalUser(password='******',
                          username='******')
        u.save()
        self.client.login(username='******', password='******')
        data = {
            'data': 'fake_testing_data_create_fail',
            'name': 'my_project'
        }
        response = self.client.post(reverse('api:project-create'), data)
        self.assertEqual(response.status_code, 403)
        try:
            project = Project.objects.get(data='fake_testing_data_create_fail')
        except:
            project = None
        self.assertIsNone(project)

    @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL)
    def test_update_project(self):
        u = ElementalUser(password='******',
                          username='******')
        u.save()
        self.client.login(username='******', password='******')
        project = Project(name='name',
                          user=u,
                          data='fake_data')
        project.save()
        data = {
            "data": "new_data"
        }
        data = json.dumps(data)
        response = self.client.patch(reverse('api:project-data', args=[project.id]), data, content_type='application/json')
        try:
            project = Project.objects.get(data='new_data')
        except:
            project = None
        self.assertIsNotNone(project)
Beispiel #56
0
 def test_device_patch_by_id_toggle(self):
     switch = self.createTestSwitch()
     client = Client()
     response = client.patch("/api/devices/1", 'toggle')
     self.assertEqual(response.status_code, 200)
class VehicleEndpointTestCase(TestCase):

    def setUp(self):
        self.cars = []
        for i in range(2):
            self.cars.append(
                factories.VehicleFactory(model__model_type=models.VehicleModel.TYPE_CAR))

        self.motocycles = []
        for i in range(2):
            self.motocycles.append(
                factories.VehicleFactory(model__model_type=models.VehicleModel.TYPE_MOTOCYCLE))

        self.c = Client()
        self.list_url = reverse('api:vehicle-list')

    def test_get_must_return_list_of_all_vehicles(self):
        response = self.c.get(self.list_url)
        self.assertEqual(response.status_code, 200)

    def test_get_with_type_car_return_correct_list(self):
        url = '{}?type=car'.format(self.list_url)
        response = self.c.get(url)
        self.assertEqual(response.status_code, 200)

        self.assertEqual(len(response.data), len(self.cars))

        ids = {i['id'] for i in response.data}
        expected_ids = {i.id for i in self.cars}
        self.assertEqual(ids, expected_ids)

    def test_get_with_type_motocycle_return_correct_list(self):
        url = '{}?type=motorcycle'.format(self.list_url)
        response = self.c.get(url)
        self.assertEqual(response.status_code, 200)

        self.assertEqual(len(response.data), len(self.motocycles))

        ids = {i['id'] for i in response.data}
        expected_ids = {i.id for i in self.motocycles}
        self.assertEqual(ids, expected_ids)

    def test_get_with_automaker_return_correct_list(self):
        car = self.cars[0]
        url = '{}?auto_maker={}'.format(self.list_url, car.model.auto_maker_id)
        response = self.c.get(url)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]['id'], car.id)

    def test_get_with_model_return_correct_list(self):
        car = self.cars[0]
        url = '{}?model={}'.format(self.list_url, car.model_id)
        response = self.c.get(url)

        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]['id'], car.id)

    def test_get_with_color_return_correct_list(self):
        car = self.cars[0]
        url = '{}?color={}'.format(self.list_url, car.color)
        response = self.c.get(url)

        self.assertEqual(response.status_code, 200)

        expected = {i.id for i in models.Vehicle.objects.filter(
            color=car.color)}

        result_ids = {i['id'] for i in response.data}

        self.assertEqual(result_ids, expected)

    def test_get_with_year_range_return_correct_list(self):
        car = self.cars[0]
        start, end = car.model.year - 1, car.model.year + 1

        expected = {i.id for i in  models.Vehicle.objects.filter(
            model__year__gte=start,
            model__year__lte=end)}

        url = '{}?year_start={}&year_end={}'.format(
            self.list_url, start, end)
        response = self.c.get(url)

        ids_result = {i['id'] for i in response.data}
        self.assertEqual(ids_result, expected)
    def test_get_with_engine_range_return_correct_list(self):
        car = self.cars[0]
        start, end = car.engine - 100, car.engine + 100

        expected = {i.id for i in  models.Vehicle.objects.filter(
            engine__gte=start,
            engine__lte=end)}

        url = '{}?engine_start={}&engine_end={}'.format(
            self.list_url, start, end)
        response = self.c.get(url)

        ids_result = {i['id'] for i in response.data}
        self.assertEqual(ids_result, expected)

    def test_get_with_mileage_range_return_correct_list(self):
        car = self.cars[0]
        start, end = car.mileage - 500, car.mileage + 500

        expected = {i.id for i in  models.Vehicle.objects.filter(
            mileage__gte=start,
            mileage__lte=end)}

        url = '{}?mileage_start={}&mileage_end={}'.format(
            self.list_url, start, end)
        response = self.c.get(url)

        ids_result = {i['id'] for i in response.data}
        self.assertEqual(ids_result, expected)

    def test_call_post_must_create_an_item(self):
        model = factories.VehicleModelFactory()

        data = dict(
            model=model.id,
            color='red',
            mileage=144000,
            engine=1000
        )

        response = self.c.post(self.list_url, data=data)
        self.assertEqual(response.status_code, 201)

        models.Vehicle.objects.get(model=model, color='red',
                                   mileage=144000, engine=1000)

    def test_call_patch_must_update_an_item(self):
        vehicle = self.cars[0]

        new_mileage = vehicle.mileage + 1000

        data = dict(
            mileage=new_mileage
        )

        url = reverse('api:vehicle-detail', args=[vehicle.id])
        response = self.c.patch(url, data=json.dumps(data),
                                content_type='application/json')
        self.assertEqual(response.status_code, 200)

        vehicle.refresh_from_db()
        self.assertEqual(vehicle.mileage, new_mileage)

    def test_call_delete_must_delete_an_item(self):
        vehicle = self.cars[0]

        url = reverse('api:vehicle-detail', args=[vehicle.id])
        response = self.c.delete(url)

        self.assertEqual(response.status_code, 204)

        self.assertIsNone(models.Vehicle.objects.filter(id=vehicle.id).first())