Page size validaton, api search form tests

apiv2/forms.py

@@ -99,11 +99,8 @@ def clean_descriptors(self):
         return my_quote(descriptors) if descriptors is not None else ""
 
     def clean_normalized(self):
-        requested_normalized = self.cleaned_data['normalized']
-        normalized = ''
-        if requested_normalized:
-            normalized = '1'
-        return normalized
+        normalized = self.cleaned_data['normalized']
+        return '1' if normalized == '1' else ''
 
     def clean_page(self):
         try:
@@ -134,24 +131,21 @@ def clean_fields(self):
         return fields
 
     def clean_group_by_pack(self):
-        requested_group_by_pack = self.cleaned_data['group_by_pack']
-        group_by_pack = ''
-        try:
-            if int(requested_group_by_pack):
-                group_by_pack = '1'
-        except ValueError:
-            pass
-        return group_by_pack
+        group_by_pack = self.cleaned_data['group_by_pack']
+        return '1' if group_by_pack == '1' else ''
 
     def clean_page_size(self):
-        requested_paginate_by = self.cleaned_data[settings.APIV2['PAGE_SIZE_QUERY_PARAM']] or \
-                                settings.APIV2['PAGE_SIZE']
-        return min(int(requested_paginate_by), settings.APIV2['MAX_PAGE_SIZE'])
+        requested_paginate_by = self.cleaned_data[settings.APIV2['PAGE_SIZE_QUERY_PARAM']]
+        try:
+            paginate_by = min(int(requested_paginate_by), settings.APIV2['MAX_PAGE_SIZE'])
+        except (ValueError, TypeError):  # TypeError if None, ValueError if bad input
+            paginate_by = settings.APIV2['PAGE_SIZE']
+        return paginate_by
 
     def clean_descriptors_filter(self):
         descriptors_filter = self.cleaned_data['descriptors_filter']
         if 'descriptors_filter' in self.data and (not descriptors_filter or descriptors_filter.isspace()):
-            raise BadRequestException('Invalid descriptiors_filter.')
+            raise BadRequestException('Invalid descriptors_filter.')
         return my_quote(descriptors_filter) if descriptors_filter is not None else ""
 
     def clean_target(self):

apiv2/tests.py

@@ -17,16 +17,19 @@
 # Authors:
 #     See AUTHORS file.
 #
-from django.test import TestCase
+from django.test import TestCase, SimpleTestCase
 from django.urls import reverse
+from django.conf import settings
 
 from apiv2.models import ApiV2Client
 from apiv2.apiv2_utils import ApiSearchPaginator
 from sounds.tests import create_user_and_sounds
+from forms import SoundCombinedSearchFormAPI
 
+from exceptions import BadRequestException
 
-class TestAPiViews(TestCase):
 
+class TestAPiViews(TestCase):
     fixtures = ['initial_data']
 
     def test_pack_views_response_ok(self):
@@ -91,7 +94,6 @@ def test_basic_user_response_ok(self):
 
 
 class TestAPI(TestCase):
-
     fixtures = ['initial_data']
 
     def test_cors_header(self):
@@ -148,3 +150,129 @@ def test_page(self):
                                  'next_page_number': 3,
                                  'previous_page_number': 1,
                                  'page_num': 2})
+
+
+class TestSoundCombinedSearchFormAPI(SimpleTestCase):
+    # Query
+    def test_query_empty_valid(self):
+        for query in [' ', '', '" "', '""', "' '", "''"]:
+            form = SoundCombinedSearchFormAPI(data={'query': query})
+            self.assertTrue(form.is_valid())
+            self.assertEqual(form.cleaned_data['query'], '')
+
+    # Filter
+    def test_filter_empty_invalid(self):
+        for filt in ['', ' ']:
+            form = SoundCombinedSearchFormAPI(data={'filter': filt})
+            with self.assertRaisesMessage(BadRequestException, 'Invalid filter.'):
+                self.assertFalse(form.is_valid())
+
+    def test_filter_valid(self):
+        filt = 'text'
+        form = SoundCombinedSearchFormAPI(data={'filter': 'text'})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['filter'], filt)
+
+    # Descriptors
+    def test_descriptors_empty_valid(self):
+        form = SoundCombinedSearchFormAPI(data={})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['descriptors'], '')
+
+    def test_descriptors_valid(self):
+        descriptors = 'test'
+        form = SoundCombinedSearchFormAPI(data={'descriptors': descriptors})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['descriptors'], descriptors)
+
+    # Normalized
+    def test_normalized_valid(self):
+        normalized = '1'
+        form = SoundCombinedSearchFormAPI(data={'normalized': normalized})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['normalized'], normalized)
+
+    def test_normalized_bogus_valid(self):
+        for normalized in ['0', '', 'test']:
+            form = SoundCombinedSearchFormAPI(data={'normalized': normalized})
+            self.assertTrue(form.is_valid())
+            self.assertEqual(form.cleaned_data['normalized'], '')
+
+    # Page
+    def test_page_empty_valid(self):
+        form = SoundCombinedSearchFormAPI(data={})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['page'], 1)
+
+    def test_page_bogus_valid(self):
+        for page in ['', 'test']:
+            form = SoundCombinedSearchFormAPI(data={'page': page})
+            self.assertTrue(form.is_valid())
+            self.assertEqual(form.cleaned_data['page'], 1)
+
+    # Sort
+    def test_sort_empty_valid(self):
+        form = SoundCombinedSearchFormAPI(data={})
+        self.assertTrue(form.is_valid())
+        sort = form.cleaned_data['sort']
+        self.assertEqual(len(sort), 1)
+        self.assertEqual(sort[0], 'score desc')
+
+    def test_sort_multiple_valid(self):
+        form = SoundCombinedSearchFormAPI(data={'sort': 'rating_desc'})
+        self.assertTrue(form.is_valid())
+        sort = form.cleaned_data['sort']
+        self.assertEqual(sort[0], "avg_rating desc")
+        self.assertEqual(len(sort), 2)
+        self.assertEqual(sort[1], "num_ratings desc")
+
+    # Normalized
+    def test_group_by_pack_valid(self):
+        group_by_pack = '1'
+        form = SoundCombinedSearchFormAPI(data={'group_by_pack': group_by_pack})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['group_by_pack'], group_by_pack)
+
+    def test_group_by_pack_bogus_valid(self):
+        for group_by_pack in ['0', '', 'test']:
+            form = SoundCombinedSearchFormAPI(data={'group_by_pack': group_by_pack})
+            self.assertTrue(form.is_valid())
+            self.assertEqual(form.cleaned_data['group_by_pack'], '')
+
+    # Page size
+    def test_page_size_empty_valid(self):
+        form = SoundCombinedSearchFormAPI(data={})
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.cleaned_data[settings.APIV2['PAGE_SIZE_QUERY_PARAM']], settings.APIV2['PAGE_SIZE'])
+
+    def test_page_size_max_valid(self):
+        param = settings.APIV2['PAGE_SIZE_QUERY_PARAM']
+        form = SoundCombinedSearchFormAPI(data={param: settings.APIV2['MAX_PAGE_SIZE'] + 1})
+        self.assertTrue(form.is_valid())
+        self.assertTrue(form.cleaned_data[param], settings.APIV2['MAX_PAGE_SIZE'])
+
+    # Descriptors filter
+    def test_descriptors_filter_empty_invalid(self):
+        for descriptors_filter in ['', ' ']:
+            form = SoundCombinedSearchFormAPI(data={'descriptors_filter': descriptors_filter})
+            with self.assertRaisesMessage(BadRequestException, 'Invalid descriptors_filter.'):
+                self.assertFalse(form.is_valid())
+
+    def test_descriptors_filter_valid(self):
+        descriptors_filter = 'test'
+        form = SoundCombinedSearchFormAPI(data={'descriptors_filter': descriptors_filter})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['descriptors_filter'], descriptors_filter)
+
+    # Target
+    def test_target_empty_invalid(self):
+        for target in ['', ' ']:
+            form = SoundCombinedSearchFormAPI(data={'target': target})
+            with self.assertRaisesMessage(BadRequestException, 'Invalid target.'):
+                self.assertFalse(form.is_valid())
+
+    def test_target_valid(self):
+        target = 'test'
+        form = SoundCombinedSearchFormAPI(data={'target': target})
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['target'], target)

apiv2/views.py

@@ -282,7 +282,7 @@ def get(self, request,  *args, **kwargs):
             not search_form.cleaned_data['descriptors_filter'] and
             not self.analysis_file) \
                 or (search_form.cleaned_data['query'] is None and search_form.cleaned_data['filter'] is None):
-            raise BadRequestException(msg='At lesast one parameter from Text Search and one parameter from '
+            raise BadRequestException(msg='At least one parameter from Text Search and one parameter from '
                                           'Content Search should be included in the request.', resource=self)
         if search_form.cleaned_data['target'] and search_form.cleaned_data['query']:
             raise BadRequestException(msg='Request parameters \'target\' and \'query\' can not be used at '