Ejemplo n.º 1
0
    def test_error_view(self):
        from application.views import error
        from django.template import RequestContext, Context
        request = MagicMock()
        request.method(return_value='/x')

        # bad request
        error.bad_request(request)
        RequestContext.assert_called_with(
            request, ErrorViewModel(status=400, exception='Bad Request'))

        # permission denied
        error.permission_denied(request)
        RequestContext.assert_called_with(
            request, ErrorViewModel(status=403, exception='Permission Denied'))

        # page not found
        error.page_not_found(request)
        RequestContext.assert_called_with(
            request,
            ErrorViewModel(status=404,
                           exception='%s Not Found' % request.path))

        # method not allowed
        error.method_not_allowed(request)
        RequestContext.assert_called_with(
            request,
            ErrorViewModel(status=405,
                           exception='%s Not Allowed' % request.method))

        # server error
        error.server_error(request)
        Context.assert_called_with(
            ErrorViewModel(status=500, exception='這一定是宿命'))
Ejemplo n.º 2
0
 def test_process(self):
     request = MagicMock()
     request.method = 'GET'
     step = SimpleStep(request)
     assert isinstance(step.process(), TemplateResponse)
     request.method = 'POST'
     assert step.process() is None
Ejemplo n.º 3
0
 def test_process(self):
     request = MagicMock()
     request.method = 'GET'
     step = SimpleStep(request)
     self.assertEqual(type(step.process()), TemplateResponse)
     request.method = 'POST'
     self.assertEqual(step.process(), None)
Ejemplo n.º 4
0
 def test_process(self):
     request = MagicMock()
     request.method = 'GET'
     step = SimpleStep(request)
     assert isinstance(step.process(), TemplateResponse)
     request.method = 'POST'
     assert step.process() is None
Ejemplo n.º 5
0
 def test_process(self):
     request = MagicMock()
     request.method = 'GET'
     step = SimpleStep(request)
     self.assertEqual(type(step.process()), TemplateResponse)
     request.method = 'POST'
     self.assertEqual(step.process(), None)
Ejemplo n.º 6
0
 def TestCommandParsing(self):
     request = MagicMock()
     request.path = "/test"
     request.query = "item1=value1"
     request.remote_ip = "1.2.3.4"
     request.method = "PUT"
     request.headers = {
         'User': '******',
         'Creation-Time': 'test_time',
         'User-Agent': 'test_user_agent'
     }
     request.body="item2=value2&item2=value3&item2=value4"
     self.command = Command(request)
     self.assertEqual(self.command.command_name, 'test')
     self.assertEqual(self.command.command_type, 'PUT')
     self.assertEqual(self.command.has_param('item1'), True)
     self.assertEqual(self.command.has_param('item2'), True)
     self.assertEqual(self.command.has_param('item3'), False)
     self.assertEqual(self.command.get_param('item1'), 'value1')
     self.assertEqual('value2' in self.command.get_param('item2'), True)
     self.assertEqual('value3' in self.command.get_param('item2'), True)
     self.assertEqual('value4' in self.command.get_param('item2'), True)
     data = self.command.format_trace
     self.assertEqual(data['Username'], 'test_user')
     self.assertEqual(data['Created'], 'test_time')
     self.assertEqual(data['Source_Address'], '1.2.3.4')
     self.assertEqual(data['Source_ID'], 'test_user_agent')
Ejemplo n.º 7
0
def a_request():
    request = MagicMock()
    request.method = "post"
    request.url = "http://{}.com".format(a_string())
    request.headers = {a_string(): a_string()}
    request.body = a_string()
    return request
Ejemplo n.º 8
0
    def _make_request(
            self,
            method, postpath, reqbody,
            resreadsreq, rescode, resbody):

        m_request = MagicMock(name='Request')
        m_request.method = method
        m_request.postpath = postpath
        if reqbody is None:
            readrv = ''
        elif reqbody == 'mangled JSON':
            readrv = reqbody
        else:
            readrv = json.dumps(reqbody, indent=2)

        m_request.content.read.return_value = readrv

        r = self.tar.render(m_request)

        self.assertEqual(r, server.NOT_DONE_YET)

        expected = [
            call.setResponseCode(rescode),
            call.setHeader('Content-Type', 'application/json'),
            call.write(json.dumps(resbody, indent=2)),
            call.finish(),
        ]

        if resreadsreq:
            expected.insert(0, call.content.read())

        check_mock(self, m_request, expected)
    def assert_expire_in_extended(self, req_path, should_expire_in, should_extend, headers=None, query_string=None):
        request = MagicMock(path=req_path)
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True
        thirty_mins_ago = (datetime.datetime.now() - datetime.timedelta(minutes=30)).strftime("%Y-%m-%dT%H:%M:%S.%f")
        request.session = {"_session_security": thirty_mins_ago}

        if headers:
            request.META = headers

        if query_string:
            request.REQUEST = query_string

        before_response = {}
        response = self.middleware.process_response(request, before_response)
        self.assertIsNotNone(response.get("Session-Expires-In"))

        self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0)
        self.middleware.process_request(request)
        response2 = self.middleware.process_response(request, before_response)
        self.assertIsNotNone(response2.get("Session-Expires-In"))
        if should_extend:
            self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in, delta=1.0)
        else:
            self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0)
Ejemplo n.º 10
0
    def test_sauthc1signer_query(self):
        # The plus sign in a url query must be replaced with %20
        r = MagicMock()
        r.headers = {}
        r.url = 'https://api.stormpath.com/v1/directories?orderBy=name+asc'
        r.method = 'GET'
        r.body = None

        mock_dt = MagicMock()
        mock_dt.utcnow.return_value = datetime.datetime(2013, 7, 1, 0, 0, 0, 0)
        mock_uuid4 = MagicMock(
            return_value='a43a9d25-ab06-421e-8605-33fd1e760825')
        s = Sauthc1Signer(id='MyId', secret='Shush!')
        with patch('stormpath.auth.datetime', mock_dt):
            with patch('stormpath.auth.uuid4', mock_uuid4):
                r2 = s(r)

        self.assertEqual(r, r2)
        self.assertEqual(
            r.headers['Authorization'],
            'SAuthc1 sauthc1Id=MyId/20130701/a43a9d25-ab06-421e-8605-33fd1e760825/sauthc1_request, '
            +  # noqa
            'sauthc1SignedHeaders=host;x-stormpath-date, ' +
            'sauthc1Signature=fc04c5187cc017bbdf9c0bb743a52a9487ccb91c0996267988ceae3f10314176'
        )  # noqa
Ejemplo n.º 11
0
    def test_factory(self, mocked_get_item):
        data = deepcopy(TEST_AGREEMENT)
        agreement = MagicMock()
        agreement.id = data["agreementID"]
        agreement.title = "test_factory"

        request = MagicMock()
        request.url = "http://localhost/api/" + VERSION + "/agreements"
        request.matchdict = {
            "agreement_id": data["agreementID"],
            "document_id": "9a750db83cc64b34a879221513c13805"
        }
        request.agreement = agreement
        request.method = "POST"
        mocked_get_item.side_effect = ["test_item1", "test_item2"]
        res = factory(request)
        self.assertEqual(res, "test_item1")
        self.assertEqual(mocked_get_item.called, True)
        request.matchdict = {
            "agreement_id": data["agreementID"],
            "contract_id": "9a750db83cc64b34a879221513c13805"
        }
        res = factory(request)
        self.assertEqual(res, "test_item2")
        self.assertEqual(mocked_get_item.called, True)
        request.matchdict = {"agreement_id": data["agreementID"]}
        res = factory(request)
        self.assertEqual(res.id, data["agreementID"])
        self.assertEqual(res.title, "test_factory")
Ejemplo n.º 12
0
 def test_render_fail_disconnected(self):
     json = JSON()
     request = MagicMock()
     request.method = 'POST'
     request._disconnected = True
     # When disconnected, returns empty string
     self.assertEqual(json.render(request), '')
Ejemplo n.º 13
0
    def test_unit_register_with_POST(self):
        """
        We need to mock several things to make this unittest.

            1. request
            2. register_form() : For this, make seperate test.
                - request has **method** attribute that specifies the method of the form.
            3. Need to mock RegisterForm because we are not testing the register function.
                - RegisterForm instance should have is_valid() method that returns boolean.
            4. We need to mock HttpResponseRedirect.
        """
        with patch('user_auth.views.RegisterForm') as form:
            with patch('user_auth.views.HttpResponseRedirect') as redir:
                request = MagicMock()
                request.method = "POST" ## this will pass if request.POST == "POST" part.
                request.POST = "some_input"
                form.return_value = Mock()
                form.return_value.is_valid = Mock(return_value=True)
                # mock register_form
                form.return_value.register_form = Mock(return_value=None)
                register(request)
                # make function call
                form.assert_called_with("some_input")
                # redir.assert_called_with('/')
                self.assertTrue(form.return_value.register_form.called)
Ejemplo n.º 14
0
    def test_resolve_non_existing_endpoint(self):
        mock_http_request = MagicMock()
        mock_http_request.method = "DELETE"
        mock_api = MagicMock(spec_set=[])

        action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo")
        assert_that(action, equal_to(None))
Ejemplo n.º 15
0
 def test_render_proc_ts(self):
     """
         **test_render_proc_ts** * Test that items are grabbed correctly
     """
     with patch('cr_hunt.views.add_hunt_its') as addf:
         with patch('cr_hunt.views.redirect') as red:
             request = MagicMock()
             request.method = "POST"
             def side_effect(*args):
                 def second_call(*args):
                     return 'test321'
                 request.POST.get.side_effect = second_call
                 return 'test123'
             request.POST.get = MagicMock(side_effect=side_effect)
             #request.POST.get('title', '').return_value = 'test123'
             #request.POST.get('start', '').return_value = 'test321'
             request.user = MagicMock()
             attrs = {'is_authenticated.return_value':True}
             request.user.configure_mock(**attrs)
             request.user.username = '******'
             views.render_proc_ts(request)
             assert addf.called
             addf.assert_called_with('111222', 'test123', 'test321', 'user1')
             assert red.called #test that redirect is called
             red.assert_called_with('cr_aitem')
             red.reset_mock()
             attrs = {'is_authenticated.return_value':False}
             request.user.configure_mock(**attrs)
             views.render_proc_ts(request)
             assert red.called
             red.assert_called_with('cr_error')
Ejemplo n.º 16
0
    def test_unit_register_with_invalidPOST(self):
        """
        This function tests the **register()** function with invalid post data.
        we should mock

            1. request
            2. RegisterForm
                - is_valid()
            3. args
        """

        with patch('user_auth.views.RegisterForm') as reg:
            request = MagicMock()
            request.method = "POST"
            request.POST = "some input" # make input to RegisterForm
            reg.return_value = Mock()
            reg.return_value.is_valid = Mock(return_value=False) # make it pass the if part.
            reg.return_value.register_form = Mock(return_value=None)
            with patch('user_auth.views.render_to_response') as render:
                render.return_value = "some value"
                register(request)
                # asserts
                reg.assert_called_with("some input")
                self.assertTrue(not reg.return_value.register_form.called)
                self.assertTrue(render.called)
Ejemplo n.º 17
0
    def test_unit_login_user_with_post(self):
        """
        This function tests **login_user()** with post data.
        We need to mock

            1. request
            2. LogInForm
                - is_valid
                - cleaned_data
            3. authenticate
                - is_active
            4. render_to_response
        """
        with patch('user_auth.views.LogInForm') as form:
            request = MagicMock()
            request.method = "POST"
            request.POST = "some data"

            form.return_value = Mock()
            form.return_value.is_valid = Mock(return_value=True)
            form.return_value.login_process = Mock()
            with patch('user_auth.views.render_to_response') as render:
                login_user(request)
                form.return_value.login_process.assert_called_with(request)
                form.assert_called_with("some data")
                self.assertTrue(render.called)
Ejemplo n.º 18
0
    def test_render_fail(self):
        json = JSON()
        request = MagicMock()
        request.method = 'POST'

        def compress(contents, request):
            return contents

        self.patch(deluge.ui.web.json_api, 'compress', compress)

        def write(response_str):
            request.write_was_called = True
            response = json_lib.loads(response_str)
            self.assertEqual(response['result'], None)
            self.assertEqual(response['id'], None)
            self.assertEqual(
                response['error']['message'], 'JSONException: JSON not decodable'
            )
            self.assertEqual(response['error']['code'], 5)

        request.write = write
        request.write_was_called = False
        request._disconnected = False
        request.getHeader.return_value = 'application/json'
        self.assertEqual(json.render(request), server.NOT_DONE_YET)
        self.assertTrue(request.write_was_called)
Ejemplo n.º 19
0
    def test_should_update_email_address_for_data_sender_and_send_mail(self):
        dbm = Mock(spec=DatabaseManager)
        request = MagicMock()
        request.POST = {
            'post_data':
            json.dumps([{
                'email': 'data_sender_email',
                'reporter_id': 'rep_id'
            }])
        }
        request.method = 'POST'
        request.LANGUAGE_CODE = 'en'
        expected_contact_id_map = {'rep_id': 'data_sender_email'}
        contact = MagicMock(spec=Contact)
        contact.is_contact = False

        with patch('datawinners.entity.views.create_web_users'
                   ) as create_web_users_mock:
            with patch('datawinners.entity.views.contact_by_short_code'
                       ) as contact_by_short_code_mock:
                with patch('datawinners.entity.views.set_email_for_contact'
                           ) as set_email_for_contact_mock:
                    contact_by_short_code_mock.return_value = contact

                    _set_email_for_contacts(dbm, 'org_id', request)

                    self.assertFalse(set_email_for_contact_mock.called)
                    create_web_users_mock.assert_called_with(
                        'org_id', expected_contact_id_map, 'en')
Ejemplo n.º 20
0
 def test_render_fail_disconnected(self):
     json = JSON()
     request = MagicMock()
     request.method = 'POST'
     request._disconnected = True
     # When disconnected, returns empty string
     self.assertEqual(json.render(request), '')
Ejemplo n.º 21
0
    def test_process_response_works_not_logged_in(self):
        # this should not add header

        request = MagicMock(path="/")
        request.method = "GET"
        before_response = {}
        response = self.middleware.process_response(request, before_response)
        self.assertIsNone(response.get("Session-Expires-In"))
    def test_process_response_works_not_logged_in(self):
        # this should not add header

        request = MagicMock(path="/")
        request.method = "GET"
        before_response = {}
        response = self.middleware.process_response(request, before_response)
        self.assertIsNone(response.get("Session-Expires-In"))
Ejemplo n.º 23
0
 def test_upstream_xauth(self):
     req = MagicMock()
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'REMOTE_USER': '******'}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 24
0
    def test_resolve_non_existing_endpoint(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'DELETE'
        mock_api = MagicMock(spec_set=[])

        action = action_resolver.resolve_action(mock_http_request,
                                                api=mock_api,
                                                url='foo')
        assert_that(action, equal_to(None))
Ejemplo n.º 25
0
 def test_upstream_admin(self):
     req = MagicMock()
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'is_admin': True}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 26
0
    def test_resolve_non_existing_action_options(self):
        mock_http_request = MagicMock()
        mock_http_request.method = "OPTIONS"
        mock_api = MagicMock()
        mock_resource = object()
        mock_api.resolve_resource.return_value = mock_resource

        action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo")
        assert_that(action, equal_to(None))
Ejemplo n.º 27
0
 def test_upstream_admin(self):
     req = MagicMock()
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'is_admin': True}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 28
0
 def test_upstream_xauth(self):
     req = MagicMock()
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'REMOTE_USER': '******'}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 29
0
    def test_resolve_post_on_list_as_create_detail(self):
        mock_http_request = MagicMock()
        mock_http_request.method = "POST"
        mock_api = MagicMock()
        mock_resource = MagicMock()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.create_detail = expected_create_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo")
        assert_that(action, equal_to(expected_create_action))
Ejemplo n.º 30
0
    def test_process_response_works_logged_in_but_without_session(self):
        # this should not add header

        request = MagicMock(path="/")
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True
        before_response = {}
        response = self.middleware.process_response(request, before_response)
        self.assertIsNone(response.get("Session-Expires-In"))
Ejemplo n.º 31
0
    def test_resolve_detail_action_on_api(self):
        mock_http_request = MagicMock()
        mock_http_request.method = "DELETE"
        mock_api = MagicMock()
        mock_resource = MagicMock()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.delete_detail = expected_delete_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request, api=mock_api, url="foo/1")
        assert_that(action, equal_to(expected_delete_action))
Ejemplo n.º 32
0
    def test_get_form_class(self):
        form_class = MagicMock()
        self.mixin.form_class['GET'] = form_class
        request = MagicMock()
        request.method = 'GET'
        self.mixin.request = request

        result = self.mixin.get_form_class()

        self.assertEqual(result, form_class)
Ejemplo n.º 33
0
    def test_resolve_non_existing_action_put(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'PUT'
        mock_api = MagicMock()
        mock_resource = object()
        mock_api.resolve_resource.return_value = mock_resource

        action = action_resolver.resolve_action(mock_http_request, api=mock_api,
                                                url='foo')
        assert_that(action, equal_to(None))
    def test_process_response_works_logged_in_but_without_session(self):
        # this should not add header

        request = MagicMock(path="/")
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True
        before_response = {}
        response = self.middleware.process_response(request, before_response)
        self.assertIsNone(response.get("Session-Expires-In"))
Ejemplo n.º 35
0
 def mock_request(self, authed, path='/'):
     mock_request = MagicMock()
     mock_request.method = 'GET'
     mock_request.user.is_authenticated.return_value = authed
     mock_request.POST = {}
     mock_request.META = {}
     mock_request.session = {}
     mock_request.build_absolute_uri.return_value = path
     mock_request.get_full_path.return_value = path
     return mock_request
Ejemplo n.º 36
0
 def test_invalid_auth(self):
     req = MagicMock()
     req.headers = {'X-AUTH-TOKEN': 'IAMBAD'}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {}
     resp = MagicMock()
     with self.assertRaises(InvalidTokenError):
         validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 37
0
 def test_upstream_preauth(self):
     req = MagicMock()
     auth = {'user': '******'}
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'auth': auth}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertEquals(req.env.get('auth'), auth)
Ejemplo n.º 38
0
 def test_invalid_auth(self):
     req = MagicMock()
     req.headers = {'X-AUTH-TOKEN': 'IAMBAD'}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {}
     resp = MagicMock()
     with self.assertRaises(InvalidTokenError):
         validate_token(req, resp, {})
     self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 39
0
    def test_get_form_class(self):
        form_class = MagicMock()
        self.mixin.form_class['GET'] = form_class
        request = MagicMock()
        request.method = 'GET'
        self.mixin.request = request

        result = self.mixin.get_form_class()

        self.assertEqual(result, form_class)
Ejemplo n.º 40
0
 def test_upstream_preauth(self):
     req = MagicMock()
     auth = {'user': '******'}
     req.headers = {}
     req.method = 'GET'
     req.path = '/v2/servers'
     req.env = {'auth': auth}
     resp = MagicMock()
     validate_token(req, resp, {})
     self.assertEquals(req.env.get('auth'), auth)
Ejemplo n.º 41
0
    def test_resolve_non_existing_action_options(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'OPTIONS'
        mock_api = MagicMock()
        mock_resource = object()
        mock_api.resolve_resource.return_value = mock_resource

        action = action_resolver.resolve_action(mock_http_request,
                                                api=mock_api,
                                                url='foo')
        assert_that(action, equal_to(None))
Ejemplo n.º 42
0
 def _get_mock_request(self, twofactor_required=False, devices=None):
     devices = devices or []
     mock_request = MagicMock()
     mock_request.user.is_authenticated.return_value = True
     mock_request.user.preferredemail.email = '*****@*****.**'
     mock_request.user.twofactor_required = twofactor_required
     mock_request.method = 'GET'
     mock_request.POST = {}
     mock_request.META = {}
     mock_request.user.devices.all.return_value = devices
     return mock_request
Ejemplo n.º 43
0
    def test_resolve_put_action_on_api(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'PUT'
        mock_api = MagicMock()
        mock_resource = MockResource()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.create_or_update_detail = expected_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request, api=mock_api,
                                                url='foo/1')
        assert_that(action, equal_to(expected_action))
    def test_process_response_logged_in_with_session_but_invalid_session_security_key(self):
        request = MagicMock(path="/")
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True

        request.session = {"_session_security": u"cantp😺 😸 😻 😽 😼 🙀 😿 😹 😾arsethisasadate"}

        before_response = {}
        with self.assertRaises(UnicodeEncodeError):
            self.middleware.process_response(request, before_response)
Ejemplo n.º 45
0
    def test_get_form_kwargs_get(self, get_initial_data_mock):
        request = MagicMock()
        request.method = 'GET'
        request.POST = 'foo'
        request.FILES = 'bar'
        self.mixin.request = request

        result = self.mixin.get_form_kwargs()

        self.assertIn('initial', result)
        self.assertIn('data', result)
Ejemplo n.º 46
0
    def test_get_form_kwargs_get(self, get_initial_data_mock):
        request = MagicMock()
        request.method = 'GET'
        request.POST = 'foo'
        request.FILES = 'bar'
        self.mixin.request = request

        result = self.mixin.get_form_kwargs()

        self.assertIn('initial', result)
        self.assertIn('data', result)
Ejemplo n.º 47
0
    def test_resolve_view_action(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'GET'
        mock_api = MagicMock()
        mock_resource = MockViewResource()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.read = expected_read_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request, api=mock_api,
                                                url='foo')
        assert_that(action, equal_to(expected_read_action))
Ejemplo n.º 48
0
    def test_log_request(self, log):
        req = MagicMock()
        req.method = 'GET'
        req.path = '/'
        req.query_string = 'something=value'
        req.env = {'REQUEST_ID': '123456'}
        resp = MagicMock()
        resp.status = '200 OK'
        log_request(req, resp)

        log.info.assert_called_with('%s %s %s %s [ReqId: %s]', 'GET', '/',
                                    'something=value', '200 OK', '123456')
    def test_process_response_logged_in_with_session_but_valid_session_security_key(self):
        request = MagicMock(path="/")
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True

        request.session = {"_session_security": datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f")}
        before_response = {}

        response = self.middleware.process_response(request, before_response)
        self.assertIsNotNone(response.get("Session-Expires-In"))
        self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), EXPIRE_AFTER // 60, delta=1.0)
Ejemplo n.º 50
0
 def test_unprotected(self):
     for api in ['GET:/v2', 'GET:/v2/', 'GET:/v3.0', 'GET:/v3.0/',
                 'GET:/v10.22', 'POST:/v2/tokens', 'POST:/v2.1/tokens',
                 'GET:/v2/tokens/a8Vs7bS', 'GET:/v2.0/tokens/a8Vs7bS']:
         req = MagicMock()
         req.headers = {'X-AUTH-TOKEN': None}
         req.method = api.split(':')[0]
         req.path = api.split(':')[1]
         req.env = {}
         resp = MagicMock()
         validate_token(req, resp, {})
         self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 51
0
    def test_resolve_detail_action_on_api(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'DELETE'
        mock_api = MagicMock()
        mock_resource = MagicMock()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.delete_detail = expected_delete_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request,
                                                api=mock_api,
                                                url='foo/1')
        assert_that(action, equal_to(expected_delete_action))
Ejemplo n.º 52
0
    def test_resolve_post_on_list_as_create_detail(self):
        mock_http_request = MagicMock()
        mock_http_request.method = 'POST'
        mock_api = MagicMock()
        mock_resource = MagicMock()
        mock_api.resolve_resource.return_value = mock_resource
        mock_resource.create_detail = expected_create_action = MagicMock()

        action = action_resolver.resolve_action(mock_http_request,
                                                api=mock_api,
                                                url='foo')
        assert_that(action, equal_to(expected_create_action))
Ejemplo n.º 53
0
    def test_standard_responder_with_mount(self, request):
        responder = OpenStackResponder('/mount/point',
                                       'http://127.0.0.1:1234/v2')
        req, resp = MagicMock(), MagicMock()
        req.method = 'POST'
        req.relative_uri = '/mount/point/path/to/resource'
        responder.on_get(req, resp)

        request.assert_called_with(req.method,
                                   'http://127.0.0.1:1234/v2/path/to/resource',
                                   data=ANY,
                                   headers=req.headers,
                                   stream=True)
Ejemplo n.º 54
0
 def test_unprotected(self):
     for api in [
             'GET:/v2', 'GET:/v2/', 'GET:/v3.0', 'GET:/v3.0/',
             'GET:/v10.22', 'POST:/v2/tokens', 'POST:/v2.1/tokens',
             'GET:/v2/tokens/a8Vs7bS', 'GET:/v2.0/tokens/a8Vs7bS'
     ]:
         req = MagicMock()
         req.headers = {'X-AUTH-TOKEN': None}
         req.method = api.split(':')[0]
         req.path = api.split(':')[1]
         req.env = {}
         resp = MagicMock()
         validate_token(req, resp, {})
         self.assertIsNone(req.env.get('auth'))
Ejemplo n.º 55
0
    def test_curator_only_member(self):
        # If user is curator and no other members, can delete the group
        self.group.curator = self.user.userprofile
        self.group.save()
        self.group.add_member(self.user.userprofile, GroupMembership.MEMBER)

        request = MagicMock()
        request.user = self.user
        request.method = 'POST'

        group_delete(request, self.group.url)

        # The group was deleted
        ok_(not Group.objects.filter(url=self.group.url).exists())
Ejemplo n.º 56
0
    def test_is_manager(self):
        # Test that manager can delete group.
        manager = UserFactory.create(manager=True)
        user2 = UserFactory.create()
        self.group.add_member(user2.userprofile, GroupMembership.MEMBER)

        request = MagicMock()
        request.user = manager
        request.method = 'POST'

        group_delete(request, self.group.url)

        # The group was deleted
        ok_(not Group.objects.filter(url=self.group.url).exists())
Ejemplo n.º 57
0
    def test_not_curator(self):
        # Only one member (user2) but user requesting the view (user1) is not the curator
        # (actually, nobody is the curator)
        user2 = UserFactory.create()
        self.group.add_member(user2.userprofile, GroupMembership.MEMBER)

        request = MagicMock()
        request.user = self.user
        request.method = 'POST'

        group_delete(request, self.group.url)

        # The group was NOT deleted
        ok_(Group.objects.filter(url=self.group.url).exists())
Ejemplo n.º 58
0
def test_build_changed_url_encoding():
    """
    Test create_chroot
    """
    maintainer = MagicMock()
    maintainer.firstname.return_value = "John"
    maintainer.lastname.return_value = "Snow"

    hook = MagicMock()
    hook.enabled.return_value = True
    hook.skip_ssl = True
    hook.method = "get"
    hook.url = "http://nonsense.invalid/get/{{ build.version|urlencode }}"
    hook.body = ""

    srcrepo = MagicMock()
    srcrepo.hooks = [hook]
    srcrepo.id.return_value = 111
    srcrepo.url.return_value = "git://url"
    srcrepo.name.return_value = "srcpkg"

    build = MagicMock()
    build.maintainer.return_value = maintainer
    build.sourcerepository = srcrepo
    build.startstamp = "NOW"
    build.endstamp = "NOW"
    build.id = 1337
    build.buildtype = "deb"
    build.ci_branch = "master"
    build.git_ref = "1337"
    build.sourcename = "srcpkg"
    build.version = "0.0.0+git1-1337<>"
    build.buildstate = "successful"
    build.url = "/blah"
    build.raw_log_url = "/blub"

    with patch("molior.molior.notifier.Configuration") as cfg, patch(
            "molior.molior.notifier.trigger_hook") as trigger_hook:
        cfg.return_value.hostname = "localhorst"

        loop = asyncio.get_event_loop()
        loop.run_until_complete(build_changed(build))

        trigger_hook.assert_called_with(
            "get",
            "http://nonsense.invalid/get/{}".format(quote_plus(build.version)),
            skip_ssl=True,
            body="",
        )
Ejemplo n.º 59
0
    def test_process_response_logged_in_with_session_but_invalid_session_security_key(
            self):
        request = MagicMock(path="/")
        request.method = "GET"
        request.user = MagicMock()
        request.user.is_authenticated.return_value = True

        request.session = {
            "_session_security":
            u"cantp😺 😸 😻 😽 😼 🙀 😿 😹 😾arsethisasadate"
        }

        before_response = {}
        with self.assertRaises(UnicodeEncodeError):
            self.middleware.process_response(request, before_response)
Ejemplo n.º 60
0
    def test_helpscout_user(self):
        request = MagicMock()
        request.method = 'POST'
        request.body = json.dumps({'customer': {'email': '*****@*****.**'}})

        # User does not exist
        response = helpscout_user(request)
        self.assertTemplateUsed(response, 'django_helpscout/404.html')

        # User found
        user = User.objects.create(username='******',
                                   email='*****@*****.**',
                                   password='******')
        response = helpscout_user(request)
        self.assertTemplateUsed(response, 'django_helpscout/helpscout.html')