Пример #1
0
 def test_method_must_have_side_effects(self):
     """Method must have side effects."""
     
     from ..csrf import CSRFError
     
     mock_request = Mock()
     mock_request.method = 'b'
     
     validator = self.makeOne('token', target_methods=['a'])
     retval = validator.validate(mock_request)
     
     self.assertTrue(retval is None)
     self.assertRaises(
         AssertionError,
         mock_request.headers.get.assert_called_with,
         'X-Requested-With'
     )
     
     mock_request = Mock()
     mock_request.method = 'a'
     self.assertRaises(
         CSRFError,
         validator.validate,
         mock_request
     )
Пример #2
0
    def test_serverCreate(self):
        mock = Mock()
        mock.method = Mock(return_value=True)
        actual = mock.method()
        expected = True

        self.assertEqual(actual, expected)
Пример #3
0
def test_mock_assert_called_with_can_fail():
    test_object = Mock()

    test_object.method({'bob': 'barker'})

    with pytest.raises(AssertionError):
        test_object.method.assert_called_with(instance_of(list))
Пример #4
0
    def test_any_mock_calls_comparison_order(self):
        mock = Mock()
        d = datetime.now()

        class Foo(object):
            def __eq__(self, other):
                return False

            def __ne__(self, other):
                return True

        for d in datetime.now(), Foo():
            mock.reset_mock()

            mock(d, foo=d, bar=d)
            mock.method(d, zinga=d, alpha=d)
            mock().method(a1=d, z99=d)

            expected = [
                call(ANY, foo=ANY, bar=ANY),
                call.method(ANY, zinga=ANY, alpha=ANY),
                call(),
                call().method(a1=ANY, z99=ANY)
            ]
            self.assertEqual(expected, mock.mock_calls)
            self.assertEqual(mock.mock_calls, expected)
Пример #5
0
    def test_clientRead(self):
        mock = Mock()
        mock.method = Mock(return_value=True)

        actual = mock.method()
        expected = True

        self.assertEqual(actual, expected)
Пример #6
0
def test_spec__object():
    mock = Mock(spec=Spec())
    attrs = dir(mock)

    assert 'class_attr' in attrs
    assert '_private_attr' in attrs # constructor IS consulted

    assert 'method' in attrs
    mock.method('arg1', 'arg2') # signature is not respected

    assert 'prop_ro' in attrs
    mock.prop_ro = 'bla' # read-only is not respected
Пример #7
0
def test_spec__object():
    mock = Mock(spec=Spec())
    attrs = dir(mock)

    assert 'class_attr' in attrs
    assert '_private_attr' in attrs  # constructor IS consulted

    assert 'method' in attrs
    mock.method('arg1', 'arg2')  # signature is not respected

    assert 'prop_ro' in attrs
    mock.prop_ro = 'bla'  # read-only is not respected
Пример #8
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
Пример #9
0
    def test_deny_create_on_put_permission(self):
        permission = DenyCreateOnPutPermission()
        view = Mock()
        request = Mock()

        request.method = 'GET'
        self.assertTrue(permission.has_permission(request, view))

        request.method = 'PUT'
        self.assertTrue(permission.has_permission(request, view))

        request.method = 'PUT'
        view.get_object = Mock(side_effect=Http404)
        self.assertFalse(permission.has_permission(request, view))
    def test_deny_create_on_put_permission(self):
        permission = DenyCreateOnPutPermission()
        view = Mock()
        request = Mock()

        request.method = 'GET'
        self.assertTrue(permission.has_permission(request, view))

        request.method = 'PUT'
        self.assertTrue(permission.has_permission(request, view))

        request.method = 'PUT'
        view.get_object = Mock(side_effect=Http404)
        self.assertFalse(permission.has_permission(request, view))
Пример #11
0
    def test_mock_method_calls(self):
        mock = Mock()
        mock()
        mock.method().attribute.method()
        mock.attribute.method()

        # mock_calls: inclusive, recursive; split by '()', good for callable mocks.
        self.assertEqual(mock.mock_calls, [
            call(),
            call.method(),
            call.method().attribute.method(),
            call.attribute.method()])

        # method_calls: exclusive, recursive; terminated by '()', good for non-callable mocks.
        self.assertEqual(mock.method_calls, [call.method(), call.attribute.method()])
Пример #12
0
 def test_process_request_empty_header(self):
     request = Mock(path="/")
     request.method = "OPTIONS"
     request.META = {"HTTP_ACCESS_CONTROL_REQUEST_METHOD": ""}
     with settings_override(CORS_URLS_REGEX="^.*$"):
         response = self.middleware.process_request(request)
     self.assertIsInstance(response, HttpResponse)
Пример #13
0
def requestMock(path, method="GET", host="localhost", port=8080, isSecure=False):
    postpath = path.split('/')

    request = Mock()
    request.getRequestHostname.return_value = host
    request.getHost.return_value.port = port
    request.postpath = postpath
    request.prepath = []
    request.method = method
    request.isSecure.return_value = isSecure
    request.notifyFinish.return_value = Deferred()
    request.finished = False
    request.__klein_branch_segments__ = []

    def render(resource):
        return _render(resource, request)

    def finish():
        request.notifyFinish.return_value.callback(None)
        request.finished = True

    def processingFailed(failure):
        request.failed = failure
        request.notifyFinish.return_value.errback(failure)

    request.finish.side_effect = finish
    request.render.side_effect = render
    request.processingFailed.side_effect = processingFailed

    return request
Пример #14
0
    def test_decorate_valid_view(self):
        class ArticleForm(forms.ModelForm):
            class Meta:
                model = Article
        class ArticleView(views.CreateView):
            model = Article
            form_class = with_request(ArticleForm)
        view_class = with_request(ArticleView)
        
        self.assertTrue(hasattr(view_class, 'get_form_kwargs'))
        self.assertTrue(getattr(view_class, '_with_request_decorated', False))

        # does the get_form_kwargs return request correctly?
        view = view_class()
        # ``request`` and ``object`` are stored on the instance in ``dispatch`` 
        # method in real usage but simply store fake request now for simulating
        mock_request = Mock()
        mock_request.method = 'GET'
        view.request = mock_request
        view.object = Article()
        kwargs = view.get_form_kwargs()
        self.assertTrue('request' in kwargs)
        self.assertEqual(kwargs['request'], mock_request)
        
        # does the form created by the view correctly handle request?
        form_class = view.get_form_class()
        form = view.get_form(form_class)

        self.assertTrue(hasattr(form_class, '__init__'))
        self.assertTrue(hasattr(form_class, 'save'))
        self.assertTrue(getattr(form_class, '_with_request_decorated', False))
        
        # does the request correctly stored?
        self.assertEqual(form.request, mock_request)
 def test_get_bounding_box_of_country(self):
     request = Mock()
     request.method = 'GET'
     request.GET.get.return_value = MockGeoserver().response()
     geonames_service = Mock()
     geoserver = Mock()
     geoserver.get_admin_units_for_country.return_value = '["Districts", "County"]'
     geonames_service.query_for_country.return_value = '''
                                                       {"geonames"
                                                       :[{"countryName":"India",
                                                          "bBoxWest":68.1866760253906,
                                                          "currencyCode":"INR",
                                                          "fipsCode":"IN",
                                                          "countryCode":"IN",
                                                          "isoNumeric":"356",
                                                          "capital":"New Delhi",
                                                          "areaInSqKm":"3287590.0",
                                                          "languages":"en-IN,hi,bn,te,mr,ta,ur,gu,ml,kn,or,pa,as,ks,sd,sa,ur-IN",
                                                          "bBoxEast":97.4033126831055,
                                                          "isoAlpha3":"IND",
                                                          "continent":"AS",
                                                          "bBoxNorth":35.5042304992676,
                                                          "geonameId":1269750,
                                                          "bBoxSouth":6.74713850021362,
                                                          "population":"1147995000"}]}'''
     response = views.country_details(request, geonames_service, geoserver)
     self.assertEquals('{"north": 180, "west": -90, "admin_units": "", "country": "Request failed", "east": 90, "adm1": [], "south": -180}', response.content)
Пример #16
0
    def test_owner_or_mod_required_passes_url_parameters(self):
        @owner_or_moderator_required
        def mock_view(request, user, context):
            return None

        request = Mock(spec=('path', 'POST', 'user', 'method'))
        request.method = "POST"
        request.user = AnonymousUser()
        request.POST = {'abra': 'cadabra', 'foo': 'bar'}
        request.path = '/some/path/'
        user = self.create_user('user')
        response = mock_view(request, user, {})
        self.assertEqual(isinstance(response, HttpResponseRedirect), True)

        url = response['location']
        parsed_url = urllib.parse.urlparse(url)

        self.assertEqual(parsed_url.path, reverse('user_signin'))

        next_jwt = dict(urllib.parse.parse_qsl(parsed_url.query))['next']
        next_url = decode_jwt(next_jwt).get('next_url')
        parsed_url = urllib.parse.urlparse(next_url)

        self.assertEqual(parsed_url.path, request.path)

        query = dict(urllib.parse.parse_qsl(parsed_url.query))
        self.assertEqual(set(query.keys()), set(['foo', 'abra']))
        self.assertEqual(set(query.values()), set(['bar', 'cadabra']))
        self.assertEqual(query['abra'], 'cadabra')
Пример #17
0
def test_fakesock_socket_sendall_with_body_data_with_chunked_entry(POTENTIAL_HTTP_PORTS, old_socket, match_uriinfo):
    ("fakesock.socket#sendall should call real_sendall when not ")
    # Background:
    # Using a subclass of socket that mocks out real_sendall

    class MySocket(fakesock.socket):
        def real_sendall(self, data):
            raise AssertionError('should have never been called')

    matcher = Mock(name='matcher')
    info = Mock(name='info')
    httpretty.match_uriinfo.return_value = (matcher, info)

    # Using a mocked entry
    entry = Mock()
    entry.method = 'GET'
    entry.info.path = '/foo'

    entry.request.headers = {
        'transfer-encoding': 'chunked',
    }
    entry.request.body = b''

    # Given an instance of that socket
    socket = MySocket()
    socket._entry = entry

    # And that is is considered http
    socket.connect(('foo.com', 80))

    # When I try to send data
    socket.sendall(b"BLABLABLABLA")

    # Then the entry should have that body
    httpretty.last_request.body.should.equal(b'BLABLABLABLA')
Пример #18
0
    def test_process_request_replace_https_referer(self):
        post_middleware = CorsPostCsrfMiddleware()
        request = Mock(path='/')
        request.method = 'GET'
        request.is_secure = lambda: False
        request.META = {
            'HTTP_REFERER': 'http://foo.google.com/',
            'HTTP_HOST': 'foobar.com',
            'HTTP_ORIGIN': 'http://foo.google.com',
        }

        # test that we won't replace if the request is not secure
        with settings_override(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*',
                               CORS_REPLACE_HTTPS_REFERER=True):
            response = self.middleware.process_request(request)
        self.assertIsNone(response)
        self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META)
        self.assertEquals(request.META['HTTP_REFERER'], 'http://foo.google.com/')

        request.is_secure = lambda: True
        request.META = {
            'HTTP_REFERER': 'https://foo.google.com/',
            'HTTP_HOST': 'foobar.com',
            'HTTP_ORIGIN': 'https://foo.google.com',
        }

        # test that we won't replace with the setting off
        with settings_override(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*'):
            response = self.middleware.process_request(request)
        self.assertIsNone(response)
        self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META)
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/')

        with settings_override(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*',
                               CORS_REPLACE_HTTPS_REFERER=True):
            response = self.middleware.process_request(request)
        self.assertIsNone(response)
        self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/')
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/')

        # make sure the replace code is idempotent
        with settings_override(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*',
                               CORS_REPLACE_HTTPS_REFERER=True):
            response = self.middleware.process_view(request, None, None, None)
        self.assertIsNone(response)
        self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/')
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/')

        with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            post_middleware.process_request(request)
        self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META)
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/')

        with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            response = post_middleware.process_request(request)
        self.assertIsNone(response)
Пример #19
0
    def test_process_view_replace_https_referer(self):
        post_middleware = CorsPostCsrfMiddleware()
        request = Mock(path='/')
        request.method = 'GET'
        request.is_secure = lambda: True
        request.META = {
            'HTTP_REFERER': 'https://foo.google.com/',
            'HTTP_HOST': 'foobar.com',
            'HTTP_ORIGIN': 'https://foo.google.com',
        }
        with settings_override(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*',
                               CORS_REPLACE_HTTPS_REFERER=True):
            response = self.middleware.process_view(request, None, None, None)
        self.assertIsNone(response)
        self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/')
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/')

        with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            post_middleware.process_view(request, None, None, None)
        self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META)
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/')

        with settings_override(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            response = post_middleware.process_view(request, None, None, None)
        self.assertIsNone(response)
Пример #20
0
 def test_process_request_empty_header(self):
     request = Mock(path='/')
     request.method = 'OPTIONS'
     request.META = {'HTTP_ACCESS_CONTROL_REQUEST_METHOD': ''}
     with settings_override(CORS_URLS_REGEX='^.*$'):
         response = self.middleware.process_request(request)
     self.assertIsInstance(response, HttpResponse)
Пример #21
0
    def test_login_and_store_credentials_in_session(self):
        # only testing custom logic, which happens on POST
        # everything else is handled by django.contrib.auth
        mockrequest = Mock()
        mockrequest.method = 'POST'

        def not_logged_in(rqst):
            rqst.user.is_authenticated.return_value = False

        def set_logged_in(rqst):
            rqst.user.is_authenticated.return_value = True
            rqst.POST.get.return_value = "TEST_PASSWORD"

        # failed login
        with patch('eulfedora.views.authviews.login',
                   new=Mock(side_effect=not_logged_in)):
            mockrequest.session = dict()
            response = login_and_store_credentials_in_session(mockrequest)
            self.assert_(FEDORA_PASSWORD_SESSION_KEY not in mockrequest.session,
                         'user password for fedora should not be stored in session on failed login')

        # successful login
        with patch('eulfedora.views.authviews.login',
                   new=Mock(side_effect=set_logged_in)):
            response = login_and_store_credentials_in_session(mockrequest)
            self.assert_(FEDORA_PASSWORD_SESSION_KEY in mockrequest.session,
                         'user password for fedora should be stored in session on successful login')
            # test password stored in the mock request
            pwd = mockrequest.POST.get()
            # encrypted password stored in session
            sessionpwd = mockrequest.session[FEDORA_PASSWORD_SESSION_KEY]
            self.assertNotEqual(pwd, sessionpwd,
                                'password should not be stored in the session without encryption')
            self.assertEqual(pwd, cryptutil.decrypt(sessionpwd),
                             'user password stored in session is encrypted')
Пример #22
0
 def has_object_perm(self, auth, user, obj, method='GET'):
     perm = ProjectPermission()
     request = Mock()
     request.auth = auth
     request.user = user
     request.method = method
     return perm.has_object_permission(request, None, obj)
Пример #23
0
 def has_perm(self, method, obj, auth=None, user=None):
     perm = TeamPermission()
     request = Mock()
     request.auth = auth
     request.user = user
     request.method = method
     return perm.has_object_permission(request, None, obj)
Пример #24
0
 def has_perm(self, method, obj, auth=None, user=None):
     perm = TeamPermission()
     request = Mock()
     request.auth = auth
     request.user = user
     request.method = method
     return perm.has_object_permission(request, None, obj)
Пример #25
0
    def get_signed_grade_mock_request_with_correct_signature(self):
        """
        Generate a proper LTI request object
        """
        mock_request = Mock()
        mock_request.headers = {
            'X-Requested-With': 'XMLHttpRequest',
            'Content-Type': 'application/x-www-form-urlencoded',
            'Authorization': (
                u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",'
                'oauth_nonce="18821463", oauth_timestamp="1409321145", '
                'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", '
                'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"'
            )
        }
        mock_request.url = u'https://testurl'
        mock_request.http_method = u'POST'
        mock_request.method = mock_request.http_method

        mock_request.body = (
            '<?xml version=\'1.0\' encoding=\'utf-8\'?>\n'
            '<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">'
            '<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>'
            '<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>'
            '</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>'
            '<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2:363979ef768ca171b50f9d1bfb322131</sourcedId>'  # pylint: disable=line-too-long
            '</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>'
            '</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>'
        )

        return mock_request
Пример #26
0
def test_api_resource():
    """
    Test APIResource class
    """
    resource = pdrest.APIResource()
    resource.register("method", "method", do_nothing)

    request = Mock()

    request.method = "method"
    request.path = "method"
    result = resource._get_callback(request)
    assert result[0] == do_nothing

    resource.getChild("method", request)

    resource.unregister(regex="method")
    
    # After unregister, the callback should be gone.
    result = resource._get_callback(request)
    assert result[0] is None

    resource.getChild("method", request)
    
    resource.children = Mock(name="what")
    result = resource.getChild("method", request)
    resource.getChild("method", request)
Пример #27
0
    def test_raw_datastream_version(self):
        rqst = Mock()
        rqst.method = 'GET'
        # return empty headers for ETag condition check
        rqst.META = {}

        self.obj.text.content = 'second version content'
        self.obj.text.save()

        # retrieve the view for each version and compare
        for version in self.obj.text.history().versions:

            # get the datastream version to compare with the response
            dsversion = self.obj.getDatastreamObject(self.obj.text.id,
                as_of_date=version.created)

            response = raw_datastream_old(rqst, self.obj.pid, self.obj.text.id,
                as_of_date=version.created)
            expected, got = 200, response.status_code
            self.assertEqual(expected, got,
                'Expected %s but returned %s for raw_datastream as of %s' \
                % (expected, got, version.created))
            expected, got = 'text/plain', response['Content-Type']
            self.assertEqual(expected, got,
                'Expected %s but returned %s for mimetype on raw_datastream as of %s' \
                    % (expected, got, version.created))
            # should use version-specific checksum and size
            self.assertEqual(dsversion.checksum, response['Content-MD5'],
                'datastream checksum should be set as Content-MD5 header in the response')
            self.assertEqual(dsversion.size, int(response['Content-Length']))
            # should retrieve appropriate version of the content
            self.assertEqual(dsversion.content, response.content)
Пример #28
0
    def get_signed_grade_mock_request_with_correct_signature(self):
        """
        Generate a proper LTI request object
        """
        mock_request = Mock()
        mock_request.headers = {
            u'X-Requested-With':
            u'XMLHttpRequest',
            u'Content-Type':
            u'application/x-www-form-urlencoded',
            u'Authorization':
            (u'OAuth realm="https://testurl/", oauth_body_hash="wwzA3s8gScKD1VpJ7jMt9b%2BMj9Q%3D",'
             u'oauth_nonce="18821463", oauth_timestamp="1409321145", '
             u'oauth_consumer_key="__consumer_key__", oauth_signature_method="HMAC-SHA1", '
             u'oauth_version="1.0", oauth_signature="fHsE1hhIz76/msUoMR3Lyb7Aou4%3D"'
             )
        }
        mock_request.url = u'https://testurl'
        mock_request.http_method = u'POST'
        mock_request.method = mock_request.http_method

        mock_request.body = (
            u'<?xml version=\'1.0\' encoding=\'utf-8\'?>\n'
            u'<imsx_POXEnvelopeRequest xmlns="http://www.imsglobal.org/services/ltiv1p1/xsd/imsoms_v1p0">'
            u'<imsx_POXHeader><imsx_POXRequestHeaderInfo><imsx_version>V1.0</imsx_version>'
            u'<imsx_messageIdentifier>edX_fix</imsx_messageIdentifier></imsx_POXRequestHeaderInfo>'
            u'</imsx_POXHeader><imsx_POXBody><replaceResultRequest><resultRecord><sourcedGUID>'
            u'<sourcedId>MITxLTI/MITxLTI/201x:localhost%3A8000-i4x-MITxLTI-MITxLTI-lti-3751833a214a4f66a0d18f63234207f2'
            u':363979ef768ca171b50f9d1bfb322131</sourcedId>'
            u'</sourcedGUID><result><resultScore><language>en</language><textString>0.32</textString></resultScore>'
            u'</result></resultRecord></replaceResultRequest></imsx_POXBody></imsx_POXEnvelopeRequest>'
        ).encode('utf-8')

        return mock_request
Пример #29
0
 def test_process_request_empty_header(self):
     request = Mock(path='/')
     request.method = 'OPTIONS'
     request.META = {'HTTP_ACCESS_CONTROL_REQUEST_METHOD': ''}
     with settings_override(CORS_URLS_REGEX='^.*$'):
         response = self.middleware.process_request(request)
     self.assertIsInstance(response, HttpResponse)
Пример #30
0
    def test_process_view_replace_https_referer(self):
        post_middleware = CorsPostCsrfMiddleware()
        request = Mock(path='/')
        request.method = 'GET'
        request.is_secure = lambda: True
        request.META = {
            'HTTP_REFERER': 'https://foo.google.com/',
            'HTTP_HOST': 'foobar.com',
            'HTTP_ORIGIN': 'https://foo.google.com',
        }
        with override_settings(CORS_URLS_REGEX='^.*$',
                               CORS_ORIGIN_REGEX_WHITELIST='.*google.*',
                               CORS_REPLACE_HTTPS_REFERER=True):
            response = self.middleware.process_view(request, None, None, None)
        self.assertIsNone(response)
        self.assertEquals(request.META['ORIGINAL_HTTP_REFERER'], 'https://foo.google.com/')
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foobar.com/')

        with override_settings(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            post_middleware.process_view(request, None, None, None)
        self.assertTrue('ORIGINAL_HTTP_REFERER' not in request.META)
        self.assertEquals(request.META['HTTP_REFERER'], 'https://foo.google.com/')

        with override_settings(CORS_URLS_REGEX='^.*$', CORS_REPLACE_HTTPS_REFERER=True):
            response = post_middleware.process_view(request, None, None, None)
        self.assertIsNone(response)
Пример #31
0
 def has_object_perm(self, auth, user, obj, method="GET"):
     perm = OrganizationPermission()
     request = Mock()
     request.auth = auth
     request.user = user
     request.method = method
     return perm.has_object_permission(request, None, obj)
Пример #32
0
def requestMock(path, method="GET", host="localhost", port=8080, isSecure=False):
    postpath = path.split('/')

    request = Mock()
    request.getRequestHostname.return_value = host
    request.getHost.return_value.port = port
    request.postpath = postpath
    request.prepath = []
    request.method = method
    request.isSecure.return_value = isSecure
    request.notifyFinish.return_value = Deferred()
    request.finished = False
    request.__klein_branch_segments__ = []

    def render(resource):
        return _render(resource, request)

    def finish():
        request.notifyFinish.return_value.callback(None)
        request.finished = True

    def processingFailed(failure):
        request.failed = failure
        request.notifyFinish.return_value.errback(failure)

    request.finish.side_effect = finish
    request.render.side_effect = render
    request.processingFailed.side_effect = processingFailed

    return request
Пример #33
0
    def test_raw_audit_trail(self):
        rqst = Mock()
        rqst.method = 'GET'

        # created with no ingest message = no audit trail
        self.assertRaises(Http404, raw_audit_trail, rqst, self.obj.pid)

        # modify object so it will have an audit trail
        self.obj.dc.content.title = 'audit this!'
        changelog = 'I just changed the title'
        self.obj.save(changelog)
        response = raw_audit_trail(rqst, self.obj.pid)
        expected, got = 200, response.status_code
        self.assertEqual(expected, got,
            'Expected %s but returned %s for raw_audit_trail' \
                % (expected, got))
        expected, got = 'text/xml', response['Content-Type']
        self.assertEqual(expected, got,
            'Expected %s but returned %s for mimetype on raw_audit_trail' \
                % (expected, got))
        self.assert_(b'<audit:auditTrail' in response.content)
        self.assert_(
            force_bytes('<audit:justification>%s</audit:justification>' %
                        changelog) in response.content)
        self.assert_('Last-Modified' in response)
Пример #34
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
def request(method='GET', form={}):
    request = Mock()
    request.method = method
    request.form = form
    request.headers = Mock()
    request.headers.get = Mock()
    request.headers.get.return_value = "application/hal+json"
    return request
Пример #36
0
    def test_Mock1(self):
        mock = Mock()
        mock.method.return_value = "foo"

        self.assertTrue(mock.method(1, 2, 3, 4), "foo")
        self.assertTrue(mock.method.called)
        with self.assertRaises(AssertionError):
            mock.method.assert_called_with(8, 6)
Пример #37
0
    def test_login_redirect_invalid_method(self):

        request = Mock()
        request.META = {}
        request.method = 'POST'
        request.session.get.return_value = None
        response = login(request)
        self.assertEqual(response.status_code, 405)
Пример #38
0
    def test_login_redirect_invalid_method(self):

        request = Mock()
        request.META = {}
        request.method = 'POST'
        request.session.get.return_value = None
        response = login(request)
        self.assertEqual(response.status_code, 405)
Пример #39
0
 def has_object_perm(self, method, obj, auth=None, user=None, is_superuser=None):
     perm = OrganizationPermission()
     request = Mock()
     request.auth = auth
     request.user = user
     request.method = method
     request.is_superuser = lambda: is_superuser if is_superuser is not None else user.is_superuser
     return perm.has_object_permission(request, None, obj)
Пример #40
0
    def test_validate_post_notsupported(self):
        '''This test case ensures creation of new persons through api always fails.'''

        request = Mock()
        request.method = "POST"

        with self.assertRaises(FantasticoRoaMethodNotSupportedError):
            self._validator.validate({}, request)
Пример #41
0
 def setUp(self):
     request = Mock()
     request.method = 'POST'
     request.POST = {'livetranslation-popup-0-msgid': 'the-msgid',
                     'livetranslation-popup-0-en': 'the-msgstr'}
     with patch('livetranslation.views.save_translations') as save:
         self.response = get_translations(request)
     self.save_translations = save
 def test_show_failure_message_when_delete_admin_unit_fails(self):
     request = Mock()
     request.session = {}
     admin_unit_manager = Mock()
     request.method = 'POST'
     request.POST.side_effect = Exception
     response = views.delete_administrative_unit(request, admin_unit_manager)
     self.assertEquals(request.session['message'], "Unable to delete Admin unit")
Пример #43
0
def request_wrap(data: dict):
    """
    Wrapper for sending data to a json handler
    """
    request = Mock()
    request.method = "POST"
    request.body = json.dumps(data).encode("utf-8")
    return request
Пример #44
0
    def test_validate_post_notsupported(self):
        '''This test case ensures creation of new persons through api always fails.'''

        request = Mock()
        request.method = "POST"

        with self.assertRaises(FantasticoRoaMethodNotSupportedError):
            self._validator.validate({}, request)
Пример #45
0
 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)
Пример #46
0
    def test_sendEvent(self, _meter):
        event = Mock(spec=["method", "retry"])
        event.retry = None
        event.method = "sendEvent"

        markEventsSent(event)

        _meter.mark.assert_called_once_with()
Пример #47
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)
Пример #48
0
    def test_sendEvents(self, _meter):
        event = Mock(spec=["method", "retry", "args"])
        event.retry = None
        event.method = "sendEvents"
        event.args = [0, 1]

        markEventsSent(event)

        _meter.mark.assert_called_once_with(len(event.args))
def mock_request(method='subtract', args=None, kwargs=None):
    mock_request = Mock(RPCRequest)
    mock_request.method = method
    mock_request.args = args or [4, 6]
    mock_request.kwargs = kwargs or {}
    mock_request.respond = Mock(RPCRequest.respond)
    mock_request.error_respond = Mock(RPCRequest.error_respond)

    return mock_request
Пример #50
0
 def test_trap_duplicate_skipped_on_standalone(self, trap_duplicate_mock):
     self.create_switch('webapps-unique-by-domain')
     request = Mock()
     request.method = 'POST'
     request.POST = {'manifest': ''}
     request.return_value = collections.namedtuple('FakeResponse',
                                                   'status_code content')
     standalone_hosted_upload(request)
     assert not trap_duplicate_mock.called
Пример #51
0
 def test_trap_duplicate_skipped_on_standalone(self, trap_duplicate_mock):
     self.create_switch('webapps-unique-by-domain')
     request = Mock()
     request.method = 'POST'
     request.POST = {'manifest': ''}
     request.return_value = collections.namedtuple('FakeResponse',
                                                   'status_code content')
     standalone_hosted_upload(request)
     assert not trap_duplicate_mock.called
Пример #52
0
    def test_mock_method_calls(self):
        mock = Mock()
        mock()
        mock.method().attribute.method()
        mock.attribute.method()

        # mock_calls: inclusive, recursive; split by '()', good for callable mocks.
        self.assertEqual(mock.mock_calls, [
            call(),
            call.method(),
            call.method().attribute.method(),
            call.attribute.method()
        ])

        # method_calls: exclusive, recursive; terminated by '()', good for non-callable mocks.
        self.assertEqual(
            mock.method_calls,
            [call.method(), call.attribute.method()])
Пример #53
0
    def test_setup_queue(self):
        result = Mock()
        result.method = Mock()
        result.method.queue = Mock()
        self.channel.queue_declare.return_value = result

        self._new_transport()

        self.channel.queue_declare.assert_called_once_with(exclusive=True)
        self.channel.basic_consume.assert_called_once_with(ANY, no_ack=True, queue=result.method.queue)
Пример #54
0
 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)
Пример #55
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)
Пример #56
0
    def build_mocks(self, resource_type='widget'):

        get_object_or_404_mock = Mock()
        resource_mock = Mock()
        resource_mock.resource_type.return_value = resource_type
        get_object_or_404_mock.return_value = resource_mock

        request_mock = Mock()
        request_mock.method = 'GET'

        return request_mock, get_object_or_404_mock, Mock()