def test_returns_the_key_as_json_if_found(self):
        request = DummyRequest(['/keys'])
        request.addArg('search', '[email protected]')
        when(self.keymanager).fetch_key('[email protected]').thenReturn(defer.succeed(OpenPGPKey('[email protected]')))

        d = self.web.get(request)

        expected = {
            u'address': u'[email protected]',
            u'encr_used': False,
            u'fingerprint': u'',
            u'last_audited_at': 0,
            u'private': False,
            u'sign_used': False,
            u'tags': [u'keymanager-active'],
            u'type': u'OpenPGPKey-active',
            u'validation': u'Weak_Chain',
            u'version': 1,
        }

        def assert_response(_):
            actual = json.loads(ast.literal_eval(request.written[0]))
            self.assertEquals(expected, actual)

        d.addCallback(assert_response)
        return d

class CallbackResourceTest(TestCase):
    def setUp(self):
        self.resource = CallbackResource()
        self.resource.factory = DecoupledRequestFactory()
        self.request = DummyRequest([''])
        self.request.method = 'POST'
        self.request.content = StringIO()

    def test_no_request_id(self):
        def on_rendered(_):
            self.assertEqual(self.request.responseCode, 503)
            self.assertEqual(['No request_id given'], self.request.written)

        return _render(self.resource, self.request).addCallback(on_rendered)

    def test_unknown_request_id(self):
        self.request.addArg('request_id', 'xxx')

        def on_rendered(_):
            self.assertEqual(self.request.responseCode, 503)
            self.assertEqual(['Request not found'], self.request.written)

        return _render(self.resource, self.request).addCallback(on_rendered)

    def test_success(self):
        self.request.addArg('request_id', 'xxx')
        self.resource.factory.requests['xxx'] = DecoupledRequest(
            self.resource.factory, 'xxx', DummyRequest(['']))

        def on_rendered(_):
            self.assertEqual(['ok'], self.request.written)

        return _render(self.resource, self.request).addCallback(on_rendered)

    def test_returns_the_key_as_json_if_found(self):
        request = DummyRequest(['/keys'])
        request.addArg('search', '[email protected]')
        when(self.keymanager).fetch_key('[email protected]').thenReturn(defer.succeed(OpenPGPKey('[email protected]')))

        d = self.web.get(request)

        expected = {
            "tags": ["keymanager-key"],
            "fingerprint": '',
            "private": False,
            'sign_used': False,
            'refreshed_at': 0,
            "expiry_date": 0,
            "address": '[email protected]',
            'encr_used': False,
            'last_audited_at': 0,
            'key_data': '',
            'length': 0,
            'key_id': '',
            'validation': 'Weak_Chain',
            'type': 'OpenPGPKey',
        }

        def assert_response(_):
            actual = json.loads(ast.literal_eval(request.written[0]))
            self.assertEquals(expected, actual)

        d.addCallback(assert_response)
        return d

    def test_returns_the_key_as_json_if_found(self):
        request = DummyRequest(["/keys"])
        request.addArg("search", "[email protected]")
        when(self.keymanager).fetch_key("[email protected]").thenReturn(defer.succeed(OpenPGPKey("[email protected]")))

        d = self.web.get(request)

        expected = {
            u"address": u"[email protected]",
            u"encr_used": False,
            u"fingerprint": u"",
            u"last_audited_at": 0,
            u"private": False,
            u"sign_used": False,
            u"tags": [u"keymanager-active"],
            u"type": u"OpenPGPKey-active",
            u"validation": u"Weak_Chain",
            u"version": 1,
        }

        def assert_response(_):
            actual = json.loads(ast.literal_eval(request.written[0]))
            self.assertEquals(expected, actual)

        d.addCallback(assert_response)
        return d

    def test_render_exceptions(self):
        """
        `SmsNotificationService.render_POST` logs any exceptions that occur
        during processing and writes a SOAP fault back to the request.
        """
        def process(*a, **kw):
            raise ValueError('What is this')
        service = SmsNotificationService(None, None)
        service.process = process
        request = DummyRequest([])
        request.content = StringIO(tostring(soap_envelope('hello')))
        d = request.notifyFinish()

        service.render_POST(request)
        self.successResultOf(d)
        self.assertEqual(http.INTERNAL_SERVER_ERROR, request.responseCode)
        failures = self.flushLoggedErrors(ValueError)
        self.assertEqual(1, len(failures))
        self.assertEqual(
            {str(SOAP_ENV.Envelope): {
                str(SOAP_ENV.Body): {
                    str(SOAP_ENV.Fault): {
                        'faultcode': 'soapenv:Server',
                        'faultstring': 'What is this'}}}},
            element_to_dict(fromstring(''.join(request.written))))

    def test_render_soap_fault(self):
        """
        `SmsNotificationService.render_POST` logs any exceptions that occur
        during processing and writes a SOAP fault back to the request. If the
        logged exception is a `SoapFault` its ``to_element`` method is invoked
        to serialize the fault.
        """
        service = SmsNotificationService(None, None)
        service.process = lambda *a, **kw: L.done()
        request = DummyRequest([])
        request.content = StringIO(tostring(L.hello()))
        d = request.notifyFinish()

        service.render_POST(request)
        self.successResultOf(d)
        self.assertEqual(http.INTERNAL_SERVER_ERROR, request.responseCode)
        failures = self.flushLoggedErrors(SoapFault)
        self.assertEqual(1, len(failures))
        self.assertEqual(
            {str(SOAP_ENV.Envelope): {
                str(SOAP_ENV.Body): {
                    str(SOAP_ENV.Fault): {
                        'faultcode': 'soapenv:Client',
                        'faultstring': 'Malformed SOAP request'}}}},
            element_to_dict(fromstring(''.join(request.written))))

 def _create_request(self, number_of_commits):
     body = {
         "commits": [{"rev": i} for i in range(number_of_commits)]
     }
     request = DummyRequest([b"/"])
     request.method = "POST"
     request.args["payload"] = [json.dumps(body)]
     return request

    def request_same_or_different_thread_thread(self):

        hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
        request1 = DummyRequest('r1')
        request1.isSecure = lambda: False
        request1.content = "llamas"
        d = deferToThreadPool(reactor, self.tp, hr.render, request1)
        return d

 def request_same_or_different_thread_thread(self):
     hr = HendrixWSGIResource(reactor, self.tp, self.wsgi_thing)
     request1 = DummyRequest([b'r1'])
     request1.isSecure = lambda: False
     request1.content = b"llamas"
     request1.client = IPv4Address("TCP", b"50.0.50.0", 5000)
     d = deferToThreadPool(reactor, self.tp, hr.render, request1)
     d.addCallback(lambda _: request1.notifyFinish())
     return d

 def test_defaultHEAD(self):
     """
     When not otherwise overridden, L{Resource.render} treats a I{HEAD}
     request as if it were a I{GET} request.
     """
     expected = b"insert response here"
     request = DummyRequest([])
     request.method = b'HEAD'
     resource = BytesReturnedRenderable(expected)
     self.assertEqual(expected, resource.render(request))

    def test_get(self):
        request = DummyRequest(['/account-recovery'])
        request.method = 'GET'
        d = self.web.get(request)

        def assert_200_when_user_logged_in(_):
            self.assertEqual(200, request.responseCode)
            self.assertIn("DOCTYPE html", request.written[0])

        d.addCallback(assert_200_when_user_logged_in)
        return d

    def test_success(self):
        def on_rendered(_):
            self.assertEqual(['backend reply'], self.request.written)

        d = _render(self.resource, self.request).addCallback(on_rendered)

        callback_request = DummyRequest([''])
        callback_request.content = StringIO('backend reply')

        self.resource.factory.requests.values()[0].notify(callback_request)
        return d

    def test_returns_404_if_key_not_found(self):
        request = DummyRequest(['/keys'])
        request.addArg('search', '[email protected]')
        when(self.keymanager).get_key_from_cache('[email protected]', OpenPGPKey).thenRaise(KeyNotFound())

        d = self.web.get(request)

        def assert_404(_):
            self.assertEquals(404, request.code)

        d.addCallback(assert_404)
        return d

    def test_returns_404_if_key_not_found(self):
        request = DummyRequest(['/keys'])
        request.addArg('search', '[email protected]')
        when(self.keymanager).fetch_key('[email protected]').thenReturn(defer.fail(KeyNotFound()))

        d = self.web.get(request)

        def assert_404(_):
            self.assertEquals(404, request.code)

        d.addCallback(assert_404)
        return d

    def test_returns_unauthorized_if_key_is_private(self):
        request = DummyRequest(['/keys'])
        request.addArg('search', '[email protected]')
        when(self.keymanager).fetch_key('[email protected]').thenReturn(defer.succeed(OpenPGPKey('[email protected]', private=True)))

        d = self.web.get(request)

        def assert_response(_):
            self.assertEquals(401, request.code)

        d.addCallback(assert_response)
        return d

    def test_post_returns_failure(self):
        request = DummyRequest(['/account-recovery'])
        request.method = 'POST'
        self.resource._handle_post = MagicMock(return_value=defer.fail(InvalidPasswordError))

        d = self.web.get(request)

        def assert_error_response(_):
            self.assertEqual(500, request.responseCode)

        d.addCallback(assert_error_response)
        return d

    def test_post_returns_successfully(self):
        request = DummyRequest(['/account-recovery'])
        request.method = 'POST'
        self.resource._handle_post = MagicMock(return_value=defer.succeed(None))

        d = self.web.get(request)

        def assert_successful_response(_):
            self.assertEqual(200, request.responseCode)

        d.addCallback(assert_successful_response)
        return d

    def test_render_GET_should_template_account_email(self):
        request = DummyRequest([''])
        request.addCookie = lambda key, value: 'stubbed'

        d = self.web.get(request)

        def assert_response(_):
            expected = "<title>{0}</title>".format(self.MAIL_ADDRESS)
            matches = re.findall(expected, request.written[0])
            self.assertEquals(len(matches), 1)

        d.addCallback(assert_response)
        return d

    def test_post_returns_successfully(self, mock_update_recovery_code):
        mock_update_recovery_code.return_value = defer.succeed("Success")
        request = DummyRequest(['/backup-account'])
        request.method = 'POST'
        request.content = MagicMock()
        request.content.getvalue.return_value = '{"email": "[email protected]"}'
        d = self.web.get(request)

        def assert_successful_response(_):
            self.assertEqual(204, request.responseCode)

        d.addCallback(assert_successful_response)
        return d

 def test_explicitAllowedMethods(self):
     """
     The L{UnsupportedMethod} raised by L{Resource.render} for an unsupported
     request method has a C{allowedMethods} attribute set to the value of the
     C{allowedMethods} attribute of the L{Resource}, if it has one.
     """
     expected = [b'GET', b'HEAD', b'PUT']
     resource = Resource()
     resource.allowedMethods = expected
     request = DummyRequest([])
     request.method = b'FICTIONAL'
     exc = self.assertRaises(UnsupportedMethod, resource.render, request)
     self.assertEqual(set(expected), set(exc.allowedMethods))