Example #1
0
    def test_channel_in_get(self):
        for ch in CHANNELS:
            request = Mock()
            request.path_info = '/'
            request.GET = dict(channel=ch)
            p = urlresolvers.Prefixer(request)
            eq_(p.get_channel(), ch)

        # Invalid channel
        request = Mock()
        request.path_info = '/'
        request.GET = dict(channel='bogus')
        p = urlresolvers.Prefixer(request)
        eq_(p.get_channel(), settings.DEFAULT_CHANNEL)
Example #2
0
File: test.py Project: n704/cst
    def test_get(self, mock_sqs):
        import json
        mock = Mock()
        mock.GET = {}
        sum_view = SumView()
        res = sum_view.get(mock)
        self.assertEquals(res.status_code, 400)
        self.assertEquals(json.loads(res.content)["error"], "No query")
        mock.GET = {'query': '1'}
        res = sum_view.get(mock)
        self.assertEquals(res.status_code, 400)
        self.assertEquals(json.loads(res.content)["error"], "No description")
        mock.GET = {'query': '1', 'description': '1'}
        # testing StoryPointsCalculator
        def test_err():
            raise StoryPointsCalculatorError("StoryPointsCalculatorError")
        storyPoints = StoryPointsCalculator('')
        with patch.object(StoryPointsCalculator, "get_score", side_effect=test_err) as mock_method:
            res = sum_view.get(mock)
            self.assertEquals(res.status_code, 400)
            self.assertEquals(json.loads(res.content)["error"], "StoryPointsCalculatorError")
        def test_err():
            raise NoDataError("NoDataError")
        storyPoints = StoryPointsCalculator('')
        with patch.object(StoryPointsCalculator, "get_score", side_effect=test_err) as mock_method:
            res = sum_view.get(mock)
            self.assertEquals(res.status_code, 400)
            self.assertEquals(json.loads(res.content)["error"], "NoDataError")
            def test_err():
                return 0
            storyPoints = StoryPointsCalculator('')
            def sqs_error(x):
                raise SQSError("SQSError")
            mock_send = Mock()
            mock_send.send_json_message = sqs_error
            mock_sqs.return_value = mock_send

            with patch.object(StoryPointsCalculator, "get_score", side_effect=test_err) as mock_method:
                res = sum_view.get(mock)
                self.assertEquals(res.status_code, 400)
                self.assertEquals(json.loads(res.content)["error"], "SQSError")

            mock_send = Mock()
            mock_send.send_json_message = lambda x: 1
            mock_sqs.return_value = mock_send
            with patch.object(StoryPointsCalculator, "get_score", side_effect=test_err) as mock_method:
                res = sum_view.get(mock)
                self.assertEquals(res.status_code, 200)
                self.assertEquals(json.loads(res.content)["success"], {"totalPoints": 0, "description": "1"})
Example #3
0
 def _test_mobile_persona_ctx(self):
     request = Mock()
     request.APP = amo.FIREFOX
     request.GET = {}
     request.user.is_authenticated.return_value = False
     request.user.mobile_addons = []
     return {'APP': amo.FIREFOX, 'LANG': 'en-US', 'request': request}
    def _test_request(self, domain, path, response_code=200, expected_event=True):
        request = Mock()
        request.path = path
        request.domain = domain
        request.GET = {}
        request.POST = {}
        request.META = {
            'HTTP_X_FORWARDED_FOR': '10.99.100.1'
        }
        request.user = Mock()
        request.user.is_authenticated = True
        request.user.username = '******'
        request.couch_user = self.user
        request.session = Mock()
        request.session.session_key = uuid.uuid4().hex

        response = Mock()
        response.status_code = response_code
        ICDSAuditMiddleware().process_response(request, response)
        events = list(ICDSAuditEntryRecord.objects.all())
        event = events[0] if events else None

        if expected_event:
            self.assertIsNotNone(event)
            self.assertEqual(event.url, path)
            self.assertEqual(event.response_code, response_code)
        else:
            self.assertIsNone(event)
Example #5
0
    def prepare_request_mock(self, data, referer='http://localhost/user_with_workspaces/Public Workspace', user=None, extra_headers={}, GET=''):
        request = Mock()
        request.method = 'POST'
        request.get_host.return_value = 'localhost'
        GET_PARAMETERS = parse_qsl(GET)
        request.GET = MagicMock()
        request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS)
        request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key]
        request.GET.urlencode.side_effect = lambda: GET
        request.COOKIES = {
            settings.SESSION_COOKIE_NAME: 'test',
        }
        request.META = {
            'HTTP_ACCEPT': 'application/json',
            'SERVER_PROTOCOL': 'http',
            'REMOTE_ADDR': '127.0.0.1',
            'content_type': 'application/json',
            'content_length': len(data),
            'HTTP_HOST': 'localhost',
            'HTTP_REFERER': referer,
            'HTTP_X_FI_WARE_OAUTH_TOKEN': 'true',
        }
        request.META.update(extra_headers)
        request.read.return_value = data
        if user is None:
            request.user = self.admin_mock
        else:
            request.user = user

        return request
Example #6
0
    def test_get_context_data(self):
        user = Mock()
        user.domain = None
        app_id = None
        request = Mock()
        request.GET = {}
        request.openrosa_headers = {}
        timing_context = Mock()
        timing_context.to_list.return_value = []
        with patch('corehq.apps.hqadmin.views.get_restore_response',
                   return_value=(HttpResponse('bad response', status=500), timing_context)):

            view = AdminRestoreView(user=user, app_id=app_id, request=request)
            context = view.get_context_data(foo='bar', view='AdminRestoreView')
            self.assertEqual(context, {
                'foo': 'bar',
                'view': 'AdminRestoreView',
                'payload': '<error>Unexpected restore response 500: bad response. If you believe this is a bug '
                           'please report an issue.</error>\n',
                'restore_id': None,
                'status_code': 500,
                'timing_data': [],
                'num_cases': 0,
                'num_locations': 0,
            })
Example #7
0
    def test_should_generate_short_code_and_import_data_senders_if_short_code_is_not_given(
            self):
        file_name = "reporters.csv"
        request = Mock()
        request.GET = {'qqfile': file_name}
        request.raw_post_data = self.csv_data_without_short_code
        organization = Mock(spec=Organization)
        with patch("datawinners.utils.get_organization_from_manager"
                   ) as get_organization_from_dbm_mock:
            with patch(
                    "datawinners.utils.get_organization") as get_organization:
                mock = Mock(return_value=organization)
                mock.org_id = 'abc'
                get_organization.return_value = mock
                get_organization_from_dbm_mock.return_value = Mock(
                    return_value=organization)

                error_message, failure_imports, success_message, imported_entities = import_data(
                    request=request,
                    manager=self.manager,
                    form_code='form_code')
                self.assertEqual(
                    4,
                    get_entity_count_for_type(self.manager,
                                              entity_type="reporter"))
                self.assertEqual(4, len(imported_entities))
                self.assertEqual('reporter', imported_entities["rep1"])
                self.assertEqual('reporter', imported_entities["rep2"])
                self.assertEqual('reporter', imported_entities["rep3"])
                self.assertEqual('reporter', imported_entities["rep4"])
Example #8
0
 def test_get(self):
     request = Mock(spec_set=['GET', 'session'])
     request.session = {}
     show = 10
     func_name = 'func_name'
     name = 'name'
     order_by = 'Time'
     request.GET = {
         'show': show,
         'func_name': func_name,
         'name': name,
         'order_by': order_by
     }
     context = ProfilingView()._create_context(request)
     self.assertDictContainsSubset(
         {
             'show': show,
             'order_by': order_by,
             'func_name': func_name,
             'name': name,
             'options_show': ProfilingView.show,
             'options_order_by': ProfilingView.order_by,
             'options_func_names': ProfilingView()._get_function_names()
         }, context)
     self.assertIn('results', context)
Example #9
0
 def test_set_default_flavour(self):
     request = Mock()
     request.GET = {}
     middleware = SetFlavourMiddleware()
     middleware.process_request(request)
     # default flavour is set
     self.assertEqual(get_flavour(), "full")
Example #10
0
    def test_pagesize(self):
        """``pagenumber`` gets the pagenumber from the request."""
        from moztrap.view.lists.templatetags.pagination import pagesize

        request = Mock()
        request.GET = {"pagenumber": 2, "pagesize": 10}
        self.assertEqual(pagesize(request), 10)
    def test_get_limit_invalid_limit_existing_error(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'limit': 'I like Pi'}

        original_error = {
            'debug': "This is an existing error",
            'status': True,
            'level': 'Important',
            'text': 'This error already exists',
            'name': "I've errored!"
        }

        expected_error = {
            'debug': "ValueError: invalid literal for int() "
                     "with base 10: 'I like Pi'",
            'status': True,
            'level': 'Warning',
            'text': 'Invalid limit. Returning all results.',
            'name': 'Bad Limit'
        }

        expected_result = [None, expected_error]
        actual_result = get_limit(mock_request, original_error)

        self.assertEqual(expected_result, actual_result)
Example #12
0
def create_fake_request(issue):
    request = Mock(HttpRequest)
    request.GET = Mock()
    request.journal = issue.journal
    request.POST = {'export-issue': issue.pk}

    return request
Example #13
0
    def test_get_limit_invalid_limit_existing_error(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'limit': 'I like Pi'}

        original_error = {
            'debug': "This is an existing error",
            'status': True,
            'level': 'Important',
            'text': 'This error already exists',
            'name': "I've errored!"
        }

        expected_error = {
            'debug': "ValueError: invalid literal for int() "
            "with base 10: 'I like Pi'",
            'status': True,
            'level': 'Warning',
            'text': 'Invalid limit. Returning all results.',
            'name': 'Bad Limit'
        }

        expected_result = [None, expected_error]
        actual_result = get_limit(mock_request, original_error)

        self.assertEqual(expected_result, actual_result)
Example #14
0
 def test_should_import_subjects_with_form_code(self):
     file_name = "reporters.csv"
     request = Mock()
     request.GET = {'qqfile': file_name}
     request.raw_post_data = self.csv_subjects_data
     organization = Mock(spec=Organization)
     entity_type = "clinic"
     define_type(self.manager, [entity_type])
     self.create_form_for_entity_type()
     with patch("datawinners.utils.get_organization_from_manager"
                ) as get_organization_from_dbm_mock:
         get_organization_from_dbm_mock.return_value = Mock(
             return_value=organization)
         with patch(
                 "datawinners.utils.get_organization") as get_organization:
             mock = Mock(return_value=organization)
             mock.org_id = 'abc'
             get_organization.return_value = mock
             error_message, failure_imports, success_message, imported_entities = import_data(
                 request=request, manager=self.manager, form_code=FORM_CODE)
             self.assertEqual(
                 4,
                 get_entity_count_for_type(self.manager,
                                           entity_type=entity_type))
             self.assertEqual(4, len(imported_entities))
             self.assertEqual(entity_type, imported_entities["cli1"])
             self.assertEqual(entity_type, imported_entities["cli2"])
             self.assertEqual(entity_type, imported_entities["cli3"])
             self.assertEqual(entity_type, imported_entities["cli4"])
Example #15
0
def test_get_results(is_valid):
    is_valid.return_value = False
    request = Mock()
    request.GET = {}
    request.default_prod = FIREFOX
    r = views._get_results(request)
    eq_(r[2], request.default_prod)
Example #16
0
    def test_get_context_data(self):
        user = Mock()
        user.domain = None
        app_id = None
        request = Mock()
        request.GET = {}
        request.openrosa_headers = {}
        timing_context = Mock()
        timing_context.to_list.return_value = []
        with patch('corehq.apps.ota.views.has_privilege', return_value=False), \
                patch('corehq.apps.hqadmin.views.get_restore_response',
                      return_value=(HttpResponse('bad response', status=500), timing_context)):

            view = AdminRestoreView(user=user, app_id=app_id, request=request)
            context = view.get_context_data(foo='bar', view='AdminRestoreView')
            self.assertEqual(context, {
                'foo': 'bar',
                'view': 'AdminRestoreView',
                'payload': '<error>Unexpected restore response 500: bad response. If you believe this is a bug '
                           'please report an issue.</error>\n',
                'restore_id': None,
                'status_code': 500,
                'timing_data': [],
                'num_cases': 0,
            })
Example #17
0
 def _test_mobile_persona_ctx(self):
     request = Mock()
     request.APP = amo.FIREFOX
     request.GET = {}
     request.user.is_authenticated.return_value = False
     request.amo_user.mobile_addons = []
     return {'APP': amo.FIREFOX, 'LANG': 'en-US', 'request': request}
    def test_get_language_from_request(self):
        request = Mock()
        request.GET = {"glang": "en"}
        request.COOKIES = {"GARNETT_LANGUAGE_CODE": "de"}
        request.META = {"HTTP_X_GARNETT_LANGUAGE_CODE": "fr"}
        with override_settings(
            GARNETT_REQUEST_LANGUAGE_SELECTORS=[
                "garnett.selectors.cookie",
                "garnett.selectors.query",
                "garnett.selectors.header",
            ]
        ):
            self.assertTrue(utils.get_language_from_request(request), "en")
        with override_settings(
            GARNETT_REQUEST_LANGUAGE_SELECTORS=[
                "garnett.selectors.cookie",
                "garnett.selectors.query",
                "garnett.selectors.header",
            ]
        ):
            self.assertTrue(utils.get_language_from_request(request), "de")

        with override_settings(
            GARNETT_REQUEST_LANGUAGE_SELECTORS=[
                "garnett.selectors.header",
                "garnett.selectors.cookie",
                "garnett.selectors.query",
            ]
        ):
            self.assertTrue(utils.get_language_from_request(request), "fr")
Example #19
0
 def test_should_import_data_senders(self):
     file_name = "reporters.csv"
     request = Mock()
     request.GET = {'qqfile' : file_name}
     request.raw_post_data = self.csv_data
     error_message, failure_imports, success, success_message = import_data(request=request,manager = self.dbm)
     self.assertTrue(success)
     self.assertEqual(4,get_entity_count_for_type(self.dbm,entity_type="reporter"))
Example #20
0
 def test_set_flavour_through_get_parameter(self, set_flavour):
     request = Mock()
     request.META = MagicMock()
     request.GET = {'flavour': 'mobile'}
     middleware = SetFlavourMiddleware()
     middleware.process_request(request)
     self.assertEqual(set_flavour.call_args,
         (('mobile', request), {'permanent': True}))
    def test_get_limit_valid_limit(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'limit': '80'}

        expected_result = [80, self.base_error]
        actual_result = get_limit(mock_request, self.base_error)

        self.assertEqual(expected_result, actual_result)
Example #22
0
    def cls(self, full_path, GET):
        """Construct mock request; instantiate and return Sort object."""
        request = Mock()
        request.GET = GET
        request.get_full_path.return_value = full_path

        from moztrap.view.lists.sort import Sort
        return Sort(request)
Example #23
0
 def test_set_amp_detect_through_get_parameter(self, set_amp_detect):
     request = Mock()
     request.META = MagicMock()
     request.GET = {'amp-content': 'amp'}
     middleware = AMPDetectionMiddleware()
     middleware.process_request(request)
     self.assertEqual(set_amp_detect.call_args,
                      call(is_amp_detect=True, request=request))
Example #24
0
 def test_default_page(self):
     request = Mock()
     request.META = MagicMock()
     request.GET = {}
     middleware = AMPDetectionMiddleware()
     middleware.process_request(request)
     # default flavour is set
     self.assertEqual(get_amp_detect(), '')
Example #25
0
    def test_get_limit_valid_limit(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'limit': '80'}

        expected_result = [80, self.base_error]
        actual_result = get_limit(mock_request, self.base_error)

        self.assertEqual(expected_result, actual_result)
Example #26
0
 def test_set_default_flavour(self):
     request = Mock()
     request.META = MagicMock()
     request.GET = {}
     middleware = SetFlavourMiddleware()
     middleware.process_request(request)
     # default flavour is set
     self.assertEqual(get_flavour(), 'full')
Example #27
0
    def cls(self, full_path, GET):
        """Construct mock request; instantiate and return Sort object."""
        request = Mock()
        request.GET = GET
        request.get_full_path.return_value = full_path

        from cc.view.lists.sort import Sort
        return Sort(request)
Example #28
0
 def test_set_amp_not_set_url_not_allowed(self, set_amp_detect):
     request = Mock()
     request.META = MagicMock()
     request.GET = {'amp-content': 'amp'}
     request.path_info = '/not-amp-url/'
     middleware = AMPDetectionMiddleware()
     middleware.process_request(request)
     self.assertEqual(0, len(set_amp_detect.call_args_list))
Example #29
0
 def test_set_flavour_through_get_parameter(self, set_flavour):
     request = Mock()
     request.META = MagicMock()
     request.GET = {'flavour': 'mobile'}
     middleware = SetFlavourMiddleware()
     middleware.process_request(request)
     self.assertEqual(set_flavour.call_args,
         (('mobile', request), {'permanent': True}))
 def test_max_request(self):
     SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10  # 10kb
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.body = 'a'.encode('ascii') * 1024 * 100  # 100kb
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertFalse(request_model.raw_body)
 def setUp(self):
     request = Mock()
     request.method = 'GET'
     request.GET = {'msgid': 'the-msgid'}
     get_all_translations = Mock(return_value={"dummy": "json"})
     with patch('livetranslation.views.get_all_translations',
                get_all_translations):
         self.response = get_translations(request)
 def test_max_request(self):
     SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10  # 10kb
     mock_request = Mock()
     mock_request.META = {"CONTENT_TYPE": "text/plain"}
     mock_request.GET = {}
     mock_request.body = "a".encode("ascii") * 1024 * 100  # 100kb
     mock_request.path = reverse("silk:requests")
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertFalse(request_model.raw_body)
Example #33
0
def test_share_view():
    u = u'\u05d0\u05d5\u05e1\u05e3'
    s = encoding.smart_str(u)
    request, obj = Mock(), Mock()
    request.GET = {'service': 'twitter'}
    obj.get_url_path.return_value = u
    sharing.views.share(request, obj, u, u)
    obj.get_url_path.return_value = s
    sharing.views.share(request, obj, s, s)
Example #34
0
 def test_no_long_url(self):
     url = '1234567890' * 19  # 190-character URL
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.path = url
     mock_request.method = 'get'
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertEqual(request_model.path, url)
Example #35
0
 def test_no_max_request(self):
     SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = -1
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.body = 'a'.encode('ascii') * 1000  # 1000 bytes?
     request_model = RequestModelFactory(
         mock_request).construct_request_model()
     self.assertTrue(request_model.raw_body)
Example #36
0
def test_share_view():
    u = u'\u05d0\u05d5\u05e1\u05e3'
    s = encoding.smart_str(u)
    request, obj = Mock(), Mock()
    request.GET = {'service': 'twitter'}
    obj.get_url_path.return_value = u
    sharing.views.share(request, obj, u, u)
    obj.get_url_path.return_value = s
    sharing.views.share(request, obj, s, s)
Example #37
0
 def test_no_long_url(self):
     url = '1234567890' * 19  # 190-character URL
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.path = url
     mock_request.method = 'get'
     request_model = RequestModelFactory(
         mock_request).construct_request_model()
     self.assertEqual(request_model.path, url)
 def test_no_max_request(self):
     SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = -1
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.path = reverse('silk:requests')
     mock_request.method = 'get'
     mock_request.body = 'a'.encode('ascii') * 1000  # 1000 bytes?
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertTrue(request_model.raw_body)
 def test_max_request(self):
     SilkyConfig().SILKY_MAX_REQUEST_BODY_SIZE = 10  # 10kb
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.method = 'get'
     mock_request.body = 'a'.encode('ascii') * 1024 * 100  # 100kb
     mock_request.path = reverse('silk:requests')
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertFalse(request_model.raw_body)
Example #40
0
 def test_should_import_data_senders(self):
     file_name = "reporters.csv"
     request = Mock()
     request.GET = {'qqfile': file_name}
     request.raw_post_data = self.csv_data
     error_message, failure_imports, success, success_message = import_data(
         request=request, manager=self.dbm)
     self.assertTrue(success)
     self.assertEqual(
         4, get_entity_count_for_type(self.dbm, entity_type="reporter"))
Example #41
0
 def test_valid_number_but_not_allowed(self):
     """Value that is a sane number but not in the
     PAGESIZES list"""
     request = Mock()
     request.GET = {"pagesize": 99, "pagenumber": 1}
     self.assertRaises(
         SuspiciousOperation,
         self.func,
         request
     )
Example #42
0
 def test_long_url(self):
     url = '1234567890' * 200  # 2000-character URL
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.method = 'get'
     mock_request.path = url
     request_model = RequestModelFactory(mock_request).construct_request_model()
     self.assertEqual(request_model.path, '%s...%s' % (url[:94], url[1907:]))
     self.assertEqual(len(request_model.path), 190)
Example #43
0
 def test_long_url(self):
     url = '1234567890' * 200  # 2000-character URL
     mock_request = Mock()
     mock_request.META = {'CONTENT_TYPE': 'text/plain'}
     mock_request.GET = {}
     mock_request.method = 'get'
     mock_request.path = url
     request_model = RequestModelFactory(
         mock_request).construct_request_model()
     self.assertEqual(request_model.path,
                      '%s...%s' % (url[:94], url[1907:]))
     self.assertEqual(len(request_model.path), 190)
Example #44
0
 def get_view_context(self, view_class, data=None, user=None, method='GET'):
     spec = ['user']
     assert(method in ('GET', 'POST'))
     spec.append(method)
     request = Mock(spec=spec)
     if method == 'GET':
         request.GET = data
     else:
         request.POST = data
     setattr(request, method, data)
     request.user = user
     return view_class().get_context(request)
Example #45
0
    def test_unicode_path(self):
        request = Mock()
        request.GET = {u'member': [u'1']}
        request.method = 'GET'
        request.path = '/api/0/organizations/üuuuu/'
        endpoint = Endpoint()
        result = endpoint.build_cursor_link(request, 'next', '1492107369532:0:0')

        assert result == (
            '<http://testserver/api/0/organizations/%C3%BCuuuu/?'
            'member=%5Bu%271%27%5D&cursor=1492107369532:0:0>;'
            ' rel="next"; results="true"; cursor="1492107369532:0:0\"'
        )
Example #46
0
 def test_default(self):
     request = Mock(spec_set=['GET'])
     request.GET = {}
     context = ProfilingView()._create_context(request)
     self.assertDictContainsSubset({
                                       'show': ProfilingView.default_show,
                                       'order_by': ProfilingView.defualt_order_by,
                                       'options_show': ProfilingView.show,
                                       'options_order_by': ProfilingView.order_by,
                                       'options_func_names': ProfilingView()._get_function_names()
                                   }, context)
     self.assertNotIn('path', context)
     self.assertIn('results', context)
    def test_get_lat_long_prox_valid_lat_long_prox(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'lat': '45.6', 'lng': '-123.4', 'proximity': '25'}

        point = fromstr('POINT (-123.4000000000000057 45.6000000000000014)',
                        srid=4326)

        expected_result = [point, 25, None, self.base_error]
        actual_result = get_lat_long_prox(mock_request, self.base_error)

        self.assertEqual(expected_result[1:], actual_result[1:])
        self.assertEqual(expected_result[0].x, actual_result[0].x)
        self.assertEqual(expected_result[0].y, actual_result[0].y)
Example #48
0
    def test_unicode_path(self):
        request = Mock()
        request.GET = {u'member': [u'1']}
        request.method = 'GET'
        request.path = '/api/0/organizations/üuuuu/'
        endpoint = Endpoint()
        result = endpoint.build_cursor_link(request, 'next',
                                            '1492107369532:0:0')

        assert result == (
            '<http://testserver/api/0/organizations/%C3%BCuuuu/?'
            'member=%5Bu%271%27%5D&cursor=1492107369532:0:0>;'
            ' rel="next"; results="true"; cursor="1492107369532:0:0\"')
Example #49
0
    def test_get_lat_long_prox_valid_lat_long_prox(self, mock_request):
        mock_request = Mock()
        mock_request.GET = {'lat': '45.6', 'lng': '-123.4', 'proximity': '25'}

        point = fromstr('POINT (-123.4000000000000057 45.6000000000000014)',
                        srid=4326)

        expected_result = [point, 25, None, self.base_error]
        actual_result = get_lat_long_prox(mock_request, self.base_error)

        self.assertEqual(expected_result[1:], actual_result[1:])
        self.assertEqual(expected_result[0].x, actual_result[0].x)
        self.assertEqual(expected_result[0].y, actual_result[0].y)
Example #50
0
    def test_unicode_path(self):
        request = Mock()
        request.GET = {u"member": [u"1"]}
        request.method = "GET"
        request.path = "/api/0/organizations/üuuuu/"
        endpoint = Endpoint()
        result = endpoint.build_cursor_link(request, "next",
                                            "1492107369532:0:0")

        assert result == (
            "<http://testserver/api/0/organizations/%C3%BCuuuu/?"
            "member=%5Bu%271%27%5D&cursor=1492107369532:0:0>;"
            ' rel="next"; results="true"; cursor="1492107369532:0:0"')
Example #51
0
    def prepare_request_mock(
            self,
            data=None,
            referer='http://localhost/user_with_workspaces/public-workspace',
            user=None,
            extra_headers={},
            GET='',
            use_deprecated_code=False):

        request = Mock()
        request.get_host.return_value = 'localhost'
        GET_PARAMETERS = parse_qsl(GET)
        request.GET = MagicMock()
        request.GET.__len__.side_effect = lambda: len(GET_PARAMETERS)
        request.GET.__getitem__.side_effect = lambda key: GET_PARAMETERS[key]
        request.GET.urlencode.side_effect = lambda: GET
        request.COOKIES = {
            settings.SESSION_COOKIE_NAME: 'test',
        }
        request.META = {
            'HTTP_ACCEPT': 'application/json',
            'SERVER_PROTOCOL': 'http',
            'REMOTE_ADDR': '127.0.0.1',
            'HTTP_HOST': 'localhost',
            'HTTP_REFERER': referer,
        }
        if data is not None:
            request.method = 'POST'
            data = data.encode('utf-8')
            request.META['content_type'] = 'application/json'
            request.META['content_length'] = len(data)
            request.read.return_value = data
        else:
            request.method = 'GET'

        if use_deprecated_code:
            request.META['HTTP_X_FI_WARE_OAUTH_TOKEN'] = 'true'
            extra_headers = {
                self.deprecation_mapping[key]: value
                for key, value in six.iteritems(extra_headers)
            }
        else:
            request.META['HTTP_FIWARE_OAUTH_TOKEN'] = 'true'

        request.META.update(extra_headers)
        if user is None:
            request.user = self.admin_mock
        else:
            request.user = user

        return request
Example #52
0
 def test_default(self):
     request = Mock(spec_set=['GET'])
     request.GET = {}
     context = ProfilingView()._create_context(request)
     self.assertDictContainsSubset(
         {
             'show': ProfilingView.default_show,
             'order_by': ProfilingView.defualt_order_by,
             'options_show': ProfilingView.show,
             'options_order_by': ProfilingView.order_by,
             'options_func_names': ProfilingView()._get_function_names()
         }, context)
     self.assertNotIn('path', context)
     self.assertIn('results', context)
Example #53
0
 def test_default(self):
     request = Mock(spec_set=['GET', 'session'])
     request.session = {}
     request.GET = {}
     context = RequestsView()._create_context(request)
     self.assertDictContainsSubset({
                                       'show': RequestsView.default_show,
                                       'order_by': RequestsView.defualt_order_by,
                                       'options_show': RequestsView.show,
                                       'options_order_by': RequestsView.order_by,
                                       'options_paths': RequestsView()._get_paths()
                                   }, context)
     self.assertNotIn('path', context)
     self.assertIn('results', context)
Example #54
0
def test_share_view_for_webapp():
    u = u'\u05d0\u05d5\u05e1\u05e3'
    s = encoding.smart_str(u)
    request, obj = Mock(), Mock()
    request.GET = {'service': 'twitter'}
    obj.get_url_path.return_value = u
    obj.is_webapp = Mock()
    obj.is_webapp.return_value = True
    sharing.views.share(request, obj, u, u)
    obj.get_url_path.return_value = s
    res = sharing.views.share(request, obj, s, s)
    qs = parse_qs(urlparse(res['Location']).query)
    assert 'Firefox Marketplace' in qs['status'][0], (
                                    'Unexpected status: %s' % qs['status'][0])
Example #55
0
    def test_provides_cors_features_false(self):
        url = URL('http://moth/')
        fr = FuzzableRequest(url)

        http_response = HTTPResponse(200, '', Headers(), url, url)

        url_opener_mock = Mock()
        url_opener_mock.GET = MagicMock(return_value=http_response)

        cors = provides_cors_features(fr, url_opener_mock, None)

        call_header = Headers({'Origin': 'www.w3af.org'}.items())
        url_opener_mock.GET.assert_called_with(url, headers=call_header)

        self.assertFalse(cors)
Example #56
0
    def test_src_retained(self):
        a = Addon.objects.get(pk=4664)
        a.suggested_amount = '12'

        settings = Mock()
        settings.MAX_CONTRIBUTION = 5

        request = Mock()
        request.GET = {'src': 'direct'}

        c = {'LANG': 'en-us', 'APP': amo.FIREFOX, 'settings': settings,
             'request': request}

        s = contribution(c, a)
        doc = PyQuery(s)
        eq_(doc('input[name=source]').attr('value'), 'direct')
Example #57
0
    def test_provides_cors_features_true(self):
        url = URL('http://moth/')
        fr = FuzzableRequest(url)

        hdrs = {'Access-Control-Allow-Origin': 'http://www.w3af.org/'}.items()
        cors_headers = Headers(hdrs)
        http_response = HTTPResponse(200, '', cors_headers, url, url)

        url_opener_mock = Mock()
        url_opener_mock.GET = MagicMock(return_value=http_response)

        cors = provides_cors_features(fr, url_opener_mock, None)

        url_opener_mock.GET.assert_called_with(url, debugging_id=None)

        self.assertTrue(cors)
Example #58
0
    def test_paginate_outsize_known_size(self):
        from moztrap.model.tags.models import Tag

        tpl = template.Template(
            "{% load pagination %}{% paginate queryset as pager %}"
            "{% for obj in pager.objects %}{{ obj }} {% endfor %}")

        request = Mock()
        request.GET = {"pagesize": 99, "pagenumber": 1}

        qs = Tag.objects.all()
        self.assertRaises(
            SuspiciousOperation,
            tpl.render,
            template.Context({"request": request, "queryset": qs})
        )
Example #59
0
    def test_contribution_box(self):
        a = Addon.objects.get(pk=7661)
        a.suggested_amount = '12'

        settings = Mock()
        settings.MAX_CONTRIBUTION = 5

        request = Mock()
        request.GET = {'src': 'direct'}

        c = {'LANG': 'en-us', 'APP': amo.FIREFOX, 'settings': settings,
             'request': request}

        s = contribution(c, a)
        doc = PyQuery(s)
        # make sure input boxes are rendered correctly (bug 555867)
        assert doc('input[name=onetime-amount]').length == 1