コード例 #1
0
    def test_pagination_build_query_string(self):
        # Test the following cases confirm expected string is returned
        # A) all defaults - expect next and prev page numbers only
        # B) non-default sort - expect page numbers with sort
        # C) non-default num - expect page numbers with num
        # D) non-default sort and num - expect page numbers with num and sort
        # E) no page_obj - expect None
        # Run where prev_page = 2 & next_page = 4

        default_num = '10'
        default_sort = '-id'

        decision_list = DecisionList()
        decision_list.default_num_items = default_num

        # Set up a dummy page object
        class DummyPageObject:
            def __init__(self, **kwargs):
                self.__dict__.update(kwargs)
        page_obj = DummyPageObject(previous_page_number=lambda: 2, next_page_number=lambda: 4)

        test_cases = [{'name': 'Test A', 'page_obj': page_obj, 'context': {'num': default_num, 'sort': default_sort}, 'expectedprev': '?page=2', 'expectednext': '?page=4'},
                      {'name': 'Test B', 'page_obj': page_obj, 'context': {'num': default_num, 'sort': 'excerpt'}, 'expectedprev': '?sort=excerpt&page=2', 'expectednext': '?sort=excerpt&page=4'},
                      {'name': 'Test C', 'page_obj': page_obj, 'context': {'num': '25', 'sort': default_sort}, 'expectedprev': '?num=25&page=2', 'expectednext': '?num=25&page=4'},
                      {'name': 'Test D', 'page_obj': page_obj, 'context': {'num': '25', 'sort': 'excerpt'}, 'expectedprev': '?sort=excerpt&num=25&page=2', 'expectednext': '?sort=excerpt&num=25&page=4'},
                      {'name': 'Test E', 'page_obj': None, 'context': {'num': '25', 'sort': 'feedback'}, 'expectedprev': None, 'expectednext': None}]

        for test_case in test_cases:
            context = test_case['context']
            context['page_obj'] = test_case['page_obj']
            returned_prev_string = decision_list.build_prev_query_string(context)
            returned_next_string = decision_list.build_next_query_string(context)
            self.assertEquals(returned_prev_string, test_case['expectedprev'], 'Did not get expected previous query')
            self.assertEquals(returned_next_string, test_case['expectednext'], 'Did not get expected next query')
コード例 #2
0
    def test_all_sorts_result_in_one_arrow_present(self):
        """Assert only one sort class is present in the decision list view"""

        # Assumes CSS will be correctly displaying the sort status
        sort_options = DecisionList().sort_table_headers

        self.create_decisions_with_different_statuses()

        # Test Ascending Sort
        for page, sort_queries in sort_options.iteritems():
            for sort_query in sort_queries:
                response = self.client.get(reverse('publicweb_item_list', args=[self.bettysorg.slug, page]), {'sort': sort_query})
                html = fromstring(response.content)
                sort_selector = CSSSelector('table.summary-list .sort-asc')
                sorts = sort_selector(html)
                self.assertEquals(len(sorts), 1, 'Number of ascending sort arrows should be 1. But is ' + str(len(sorts))
                                                 + ' for page=' + page + ' sort_query=' + sort_query)
        # Test Descending Sort
        for page, sort_queries in sort_options.iteritems():
            for sort_query in sort_queries:
                response = self.client.get(reverse('publicweb_item_list', args=[self.bettysorg.slug, page]), {'sort': '-' + sort_query})
                html = fromstring(response.content)
                sort_selector = CSSSelector('table.summary-list .sort-desc')
                sorts = sort_selector(html)
                self.assertEquals(len(sorts), 1, 'Number of descending sort arrows should be 1. But is ' + str(len(sorts))
                                                 + ' for page=' + page + ' sort_query=' + sort_query)
コード例 #3
0
    def test_sorting_header_links(self):
        # Ensure that the links provided in table headers give the correct next sort link
        # Use default sort for each sort_option and assert that other headers are correct.
        self.create_decisions_with_different_statuses()

        decision = DecisionList()
        default_sort_options = deepcopy(decision.sort_options)
        sort_table_headers = deepcopy(decision.sort_table_headers)
        unsortable_headers = decision.unsortable_fields[:]

        for header_list in sort_table_headers.values():
            for header in unsortable_headers:
                index = header_list.index(header)
                header_list.pop(index)

        for page, sort_queries in sort_table_headers.iteritems():
            page_url = reverse('publicweb_item_list',
                               args=[self.bettysorg.slug, page])

            sort_query_defaults = {}
            # Build expected defaults
            for sort_query in sort_queries:
                default_sort_order = default_sort_options[sort_query]
                default_sort_query = default_sort_order + sort_query
                sort_query_defaults[sort_query] = default_sort_query
            sort_query_defaults['id'] = ''  # Override the default sort for id

            for sort_query in sort_queries:
                sort_query_tests = sort_query_defaults.copy()
                test_query = sort_query_tests.pop(sort_query)

                response = self.client.get(page_url, {'sort': test_query})
                html = fromstring(response.content)

                # Loop through the shortened sort_query_tests to check that default links are being given
                for selector, sort_query_test in sort_query_tests.iteritems():
                    selector = CSSSelector('.summary-header th.' + selector +
                                           ' a')
                    link_ending = selector(html)[0].attrib['href'].split(
                        page_url)[1]

                    if sort_query_test == '':
                        self.assertFalse(link_ending)
                    else:
                        self.assertEquals(
                            link_ending.split('?sort=')[1], sort_query_test)

                # Finally check that the test_query column has the opposite sort
                selector = CSSSelector('.summary-header th.' + sort_query +
                                       ' a')
                link_ending = selector(html)[0].attrib['href'].split(
                    page_url)[1].split('?sort=')[1]
                reversed_sort_order = decision.toggle_sort_order(
                    default_sort_options[sort_query])
                expected_link_ending = reversed_sort_order + sort_query
                self.assertEquals(expected_link_ending, link_ending)
コード例 #4
0
    def test_sorting_header_links(self):
        # Ensure that the links provided in table headers give the correct next sort link
        # Use default sort for each sort_option and assert that other headers are correct.
        self.create_decisions_with_different_statuses()

        decision = DecisionList()
        default_sort_options = deepcopy(decision.sort_options)
        sort_table_headers = deepcopy(decision.sort_table_headers)
        unsortable_headers = decision.unsortable_fields[:]

        for header_list in sort_table_headers.values():
            for header in unsortable_headers:
                index = header_list.index(header)
                header_list.pop(index)

        for page, sort_queries in sort_table_headers.iteritems():
            page_url = reverse('publicweb_item_list', args=[self.bettysorg.slug, page])

            sort_query_defaults = {}
            # Build expected defaults
            for sort_query in sort_queries:
                default_sort_order = default_sort_options[sort_query]
                default_sort_query = default_sort_order + sort_query
                sort_query_defaults[sort_query] = default_sort_query
            sort_query_defaults['id'] = ''  # Override the default sort for id

            for sort_query in sort_queries:
                sort_query_tests = sort_query_defaults.copy()
                test_query = sort_query_tests.pop(sort_query)

                response = self.client.get(page_url, {'sort': test_query})
                html = fromstring(response.content)

                # Loop through the shortened sort_query_tests to check that default links are being given
                for selector, sort_query_test in sort_query_tests.iteritems():
                    selector = CSSSelector('.summary-header th.' + selector + ' a')
                    link_ending = selector(html)[0].attrib['href'].split(page_url)[1]

                    if sort_query_test == '':
                        self.assertFalse(link_ending)
                    else:
                        self.assertEquals(link_ending.split('?sort=')[1], sort_query_test)

                # Finally check that the test_query column has the opposite sort
                selector = CSSSelector('.summary-header th.' + sort_query + ' a')
                link_ending = selector(html)[0].attrib['href'].split(page_url)[1].split('?sort=')[1]
                reversed_sort_order = decision.toggle_sort_order(default_sort_options[sort_query])
                expected_link_ending = reversed_sort_order + sort_query
                self.assertEquals(expected_link_ending, link_ending)
コード例 #5
0
    def test_all_sorts_result_in_one_arrow_present(self):
        """Assert only one sort class is present in the decision list view"""

        # Assumes CSS will be correctly displaying the sort status
        sort_options = DecisionList().sort_table_headers

        self.create_decisions_with_different_statuses()

        # Test Ascending Sort
        for page, sort_queries in sort_options.iteritems():
            for sort_query in sort_queries:
                response = self.client.get(
                    reverse('publicweb_item_list',
                            args=[self.bettysorg.slug, page]),
                    {'sort': sort_query})
                html = fromstring(response.content)
                sort_selector = CSSSelector('table.summary-list .sort-asc')
                sorts = sort_selector(html)
                self.assertEquals(
                    len(sorts), 1,
                    'Number of ascending sort arrows should be 1. But is ' +
                    str(len(sorts)) + ' for page=' + page + ' sort_query=' +
                    sort_query)
        # Test Descending Sort
        for page, sort_queries in sort_options.iteritems():
            for sort_query in sort_queries:
                response = self.client.get(
                    reverse('publicweb_item_list',
                            args=[self.bettysorg.slug, page]),
                    {'sort': '-' + sort_query})
                html = fromstring(response.content)
                sort_selector = CSSSelector('table.summary-list .sort-desc')
                sorts = sort_selector(html)
                self.assertEquals(
                    len(sorts), 1,
                    'Number of descending sort arrows should be 1. But is ' +
                    str(len(sorts)) + ' for page=' + page + ' sort_query=' +
                    sort_query)
コード例 #6
0
    def test_cannot_view_decisions_when_not_member(self):

        request = self.factory.request()
        request.user = self.betty
        request.session = self.client.session
        decision = self.make_decision()
        kwargs = {
            'org_slug': decision.organization.slug,
            'status': decision.status
        }
        response = DecisionList(template_name='decision_list.html').dispatch(
            request, **kwargs)
        self.assertContains(response, decision.description)

        kwargs = {'pk': decision.pk}
        response = DecisionDetail(template_name='item_detail.html').dispatch(
            request, **kwargs)
        self.assertContains(response, decision.description)

        members = [x.username for x in decision.organization.users.all()]
        non_members = User.objects.exclude(username__in=members).exclude(
            username='******')
        self.assertTrue(non_members)

        self.login(non_members[0].username)
        request.user = self.user
        kwargs = {
            'org_slug': decision.organization.slug,
            'status': decision.status
        }
        response = DecisionList(template_name='decision_list.html').dispatch(
            request, **kwargs)
        self.assertNotContains(response, decision.description)

        kwargs = {'pk': decision.pk}
        response = DecisionDetail(template_name='item_detail.html').dispatch(
            request, **kwargs)
        self.assertNotContains(response, decision.description)
コード例 #7
0
ファイル: alt_view_test.py プロジェクト: yogiblue/econsensus
 def test_status_set_in_get_and_get_context_data(self):
     """
     More integrated test, that goes through dispatch, get, and
     get_context_data method to get the response object.
     """
     org = OrganizationFactory()
     kwargs = {'org_slug': org.slug,
               'status': Decision.PROPOSAL_STATUS}
     request = RequestFactory().get('/')
     request.user = UserFactory.build()
     request.session = {}
     dl = DecisionList.as_view()
     response = dl(request, **kwargs)
     self.assertEqual(response.context_data['tab'],
                      Decision.PROPOSAL_STATUS)
コード例 #8
0
    def test_set_sorting(self):
        # Test the following cases confirm expected string is returned
        # A) None -> -id
        # B) random -> -id
        # C) valid sort option asc -> valid sort option
        # D) valid sort option desc -> - valid sort option

        valid_sort_options = DecisionList().sort_options.keys()

        test_c = choice(valid_sort_options)
        test_d = '-' + choice(valid_sort_options)

        test_cases = [{
            'name': 'Test A',
            'sortquery': '-id',
            'expectedsort': '-id',
            'expectedsort_order': '-',
            'expectedsort_field': 'id'
        }, {
            'name': 'Test B',
            'sortquery': self._get_random_string(10),
            'expectedsort': '-id',
            'expectedsort_order': '-',
            'expectedsort_field': 'id'
        }, {
            'name': 'Test C',
            'sortquery': test_c,
            'expectedsort': test_c,
            'expectedsort_order': '',
            'expectedsort_field': test_c
        }, {
            'name': 'Test D',
            'sortquery': test_d,
            'expectedsort': test_d,
            'expectedsort_order': '-',
            'expectedsort_field': test_d[1:]
        }]
        for test_case in test_cases:
            response = self.client.get(
                reverse('publicweb_item_list',
                        args=[self.bettysorg.slug, 'proposal']),
                {'sort': test_case['sortquery']})
            self.assertEquals(
                response.context['sort'], test_case['expectedsort'],
                'Did not get expected sort with sortquery ' +
                test_case['sortquery'])
コード例 #9
0
    def test_status_is_set_in_context_data_and_limits_object_list(self):
        """
        More integrated test, that goes through dispatch, get, and
        get_context_data method to get the response object and test it.
        """
        decision = DecisionFactory(status=Decision.DECISION_STATUS)
        org = decision.organization
        archive = DecisionFactory(organization=org,
                                  status=Decision.ARCHIVED_STATUS)

        kwargs = {'org_slug': org.slug, 'status': archive.status}
        request = RequestFactory().get('/')
        request.user = UserFactory.build()
        request.session = {}
        response = DecisionList.as_view()(request, **kwargs)
        self.assertIn('tab', response.context_data.keys())
        self.assertEqual(response.context_data['tab'], archive.status)
        self.assertIn(archive, response.context_data['object_list'])
        self.assertNotIn(decision, response.context_data['object_list'])
コード例 #10
0
    def test_status_is_set_in_context_data_and_limits_object_list(self):
        """
        More integrated test, that goes through dispatch, get, and
        get_context_data method to get the response object and test it.
        """
        decision = DecisionFactory(status=Decision.DECISION_STATUS)
        org = decision.organization
        archive = DecisionFactory(organization=org, status=Decision.ARCHIVED_STATUS)

        kwargs = {'org_slug': org.slug,
                  'status': archive.status}
        request = RequestFactory().get('/')
        request.user = UserFactory.build()
        request.session = {}
        response = DecisionList.as_view()(request, **kwargs)
        self.assertIn('tab', response.context_data.keys())
        self.assertEqual(response.context_data['tab'], archive.status)
        self.assertIn(archive, response.context_data['object_list'])
        self.assertNotIn(decision, response.context_data['object_list'])
コード例 #11
0
 def test_set_status_uses_default_when_no_kwarg_is_passed(self):
     dl = DecisionList()
     dl.set_status()
     default_status = Decision.PROPOSAL_STATUS
     self.assertEqual(dl.status, default_status)
コード例 #12
0
 def test_set_status_is_correctly_set_when_kwarg_is_passed(self):
     dl = DecisionList()
     kwargs = {'status': 'test status'}
     dl.set_status(**kwargs)
     self.assertEqual(dl.status, 'test status')
コード例 #13
0
 def test_set_status_uses_default_when_no_kwarg_is_passed(self):
     dl = DecisionList()
     dl.set_status()
     default_status = DecisionList.DEFAULT
     self.assertEqual(dl.status, default_status)
コード例 #14
0
 def test_set_status_is_correctly_set_when_kwarg_is_passed(self):
     dl = DecisionList()
     kwargs = {'status': 'test status'}
     dl.set_status(**kwargs)
     self.assertEqual(dl.status, 'test status')
コード例 #15
0
ファイル: view_test.py プロジェクト: philmcmahon/econsensus
 def test_set_status_uses_default_when_no_kwarg_is_passed(self):
     dl = DecisionList()
     dl.set_status()
     default_status = Decision.PROPOSAL_STATUS
     self.assertEqual(dl.status, default_status)
コード例 #16
0
 def test_toggle_sort_order(self):
     decision = DecisionList()
     self.assertEquals('', decision.toggle_sort_order('-'))
     self.assertEquals('-', decision.toggle_sort_order(''))
コード例 #17
0
    def test_pagination_build_query_string(self):
        # Test the following cases confirm expected string is returned
        # A) all defaults - expect next and prev page numbers only
        # B) non-default sort - expect page numbers with sort
        # C) non-default num - expect page numbers with num
        # D) non-default sort and num - expect page numbers with num and sort
        # E) no page_obj - expect None
        # Run where prev_page = 2 & next_page = 4

        default_num = '10'
        default_sort = '-id'

        decision_list = DecisionList()
        decision_list.default_num_items = default_num

        # Set up a dummy page object
        class DummyPageObject:
            def __init__(self, **kwargs):
                self.__dict__.update(kwargs)

        page_obj = DummyPageObject(previous_page_number=lambda: 2,
                                   next_page_number=lambda: 4)

        test_cases = [{
            'name': 'Test A',
            'page_obj': page_obj,
            'context': {
                'num': default_num,
                'sort': default_sort
            },
            'expectedprev': '?page=2',
            'expectednext': '?page=4'
        }, {
            'name': 'Test B',
            'page_obj': page_obj,
            'context': {
                'num': default_num,
                'sort': 'excerpt'
            },
            'expectedprev': '?sort=excerpt&page=2',
            'expectednext': '?sort=excerpt&page=4'
        }, {
            'name': 'Test C',
            'page_obj': page_obj,
            'context': {
                'num': '25',
                'sort': default_sort
            },
            'expectedprev': '?num=25&page=2',
            'expectednext': '?num=25&page=4'
        }, {
            'name': 'Test D',
            'page_obj': page_obj,
            'context': {
                'num': '25',
                'sort': 'excerpt'
            },
            'expectedprev': '?sort=excerpt&num=25&page=2',
            'expectednext': '?sort=excerpt&num=25&page=4'
        }, {
            'name': 'Test E',
            'page_obj': None,
            'context': {
                'num': '25',
                'sort': 'feedback'
            },
            'expectedprev': None,
            'expectednext': None
        }]

        for test_case in test_cases:
            context = test_case['context']
            context['page_obj'] = test_case['page_obj']
            returned_prev_string = decision_list.build_prev_query_string(
                context)
            returned_next_string = decision_list.build_next_query_string(
                context)
            self.assertEquals(returned_prev_string, test_case['expectedprev'],
                              'Did not get expected previous query')
            self.assertEquals(returned_next_string, test_case['expectednext'],
                              'Did not get expected next query')
コード例 #18
0
ファイル: view_test.py プロジェクト: rrosajp/econsensus
 def test_set_status_uses_default_when_no_kwarg_is_passed(self):
     dl = DecisionList()
     dl.set_status()
     default_status = DecisionList.DEFAULT
     self.assertEqual(dl.status, default_status)
コード例 #19
0
 def test_toggle_sort_order(self):
     decision = DecisionList()
     self.assertEquals('', decision.toggle_sort_order('-'))
     self.assertEquals('-', decision.toggle_sort_order(''))