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)
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"})
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)
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
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, })
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"])
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)
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")
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)
def create_fake_request(issue): request = Mock(HttpRequest) request.GET = Mock() request.journal = issue.journal request.POST = {'export-issue': issue.pk} return request
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"])
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)
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, })
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")
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"))
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)
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)
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))
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(), '')
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')
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)
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))
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)
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)
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.body = 'a'.encode('ascii') * 1000 # 1000 bytes? request_model = RequestModelFactory( mock_request).construct_request_model() self.assertTrue(request_model.raw_body)
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)
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"))
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 )
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)
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)
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)
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\"' )
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)
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\"')
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"')
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
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_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)
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])
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)
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')
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)
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}) )
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