Пример #1
0
  def test_base_api_uri_used_instead_of_default(self):
    # Requests to the default BASE_API_URI will noticeably fail by raising an
    # AssertionError. Requests to the new URL will respond HTTP 200.
    new_base_api_uri = 'http://example.com/api/v1/'

    # If any error is raised by the server, the test suite will never exit when
    # using Python 3. This strange technique is used to raise the errors
    # outside of the mocked server environment.
    errors_in_server = []
    def server_response(request, uri, headers):
      try:
        self.assertEqual(uri, new_base_api_uri)
      except AssertionError as e:
        errors_in_server.append(e)
      return (200, headers, "")

    hp.register_uri(hp.GET, OAuthClient.BASE_API_URI, body=server_response)
    hp.register_uri(hp.GET, new_base_api_uri, body=server_response)

    client = OAuthClient(client_id, client_secret, access_token, refresh_token)
    with self.assertRaises(AssertionError):
      client._get()
      if errors_in_server: raise errors_in_server.pop()

    client2 = OAuthClient(
        client_id,
        client_secret,
        access_token,
        refresh_token,
        base_api_uri=new_base_api_uri)
    self.assertEqual(client2._get().status_code, 200)
Пример #2
0
 def test_oauth_details_required(self):
     with self.assertRaises(ValueError):
         OAuthClient(None, client_secret, access_token, refresh_token)
     with self.assertRaises(ValueError):
         OAuthClient(client_id, None, access_token, refresh_token)
     with self.assertRaises(ValueError):
         OAuthClient(client_id, client_secret, None, refresh_token)
     with self.assertRaises(ValueError):
         OAuthClient(client_id, client_secret, access_token, None)
Пример #3
0
    def test_refresh(self):
        client = OAuthClient(client_id, client_secret, access_token,
                             refresh_token)

        def server_response(request, uri, headers):
            return (200, headers, json.dumps(data))

        hp.register_uri(hp.POST,
                        client.TOKEN_ENDPOINT_URI,
                        body=server_response)

        data = {
            'access_token': 'newaccesstoken',
            'refresh_token': 'newrefreshtoken',
        }
        self.assertNotEqual(client.access_token, data['access_token'])
        self.assertNotEqual(client.refresh_token, data['refresh_token'])
        client.refresh()
        self.assertEqual(client.access_token, data['access_token'])
        self.assertEqual(client.refresh_token, data['refresh_token'])

        def server_response(request, uri, headers):
            return (400, headers, '')

        hp.reset()
        hp.register_uri(hp.POST,
                        client.TOKEN_ENDPOINT_URI,
                        body=server_response)

        client.access_token = access_token
        client.refresh_token = refresh_token
        with self.assertRaises(TokenRefreshError):
            client.refresh()
        self.assertEqual(client.access_token, access_token)
        self.assertEqual(client.refresh_token, refresh_token)
Пример #4
0
    def test_base_api_uri_used_instead_of_default(self):
        # Requests to the default BASE_API_URI will noticeably fail by raising an
        # AssertionError. Requests to the new URL will respond HTTP 200.
        new_base_api_uri = 'http://example.com/api/v1/'

        # If any error is raised by the server, the test suite will never exit when
        # using Python 3. This strange technique is used to raise the errors
        # outside of the mocked server environment.
        errors_in_server = []

        def server_response(request, uri, headers):
            try:
                self.assertEqual(uri, new_base_api_uri)
            except AssertionError as e:
                errors_in_server.append(e)
            return (200, headers, "")

        hp.register_uri(hp.GET, OAuthClient.BASE_API_URI, body=server_response)
        hp.register_uri(hp.GET, new_base_api_uri, body=server_response)

        client = OAuthClient(client_id, client_secret, access_token,
                             refresh_token)
        with self.assertRaises(AssertionError):
            client._get()
            if errors_in_server: raise errors_in_server.pop()

        client2 = OAuthClient(client_id,
                              client_secret,
                              access_token,
                              refresh_token,
                              base_api_uri=new_base_api_uri)
        self.assertEqual(client2._get().status_code, 200)
Пример #5
0
  def test_refresh(self):
    client = OAuthClient(client_id, client_secret, access_token, refresh_token)

    def server_response(request, uri, headers):
      return (200, headers, json.dumps(data))
    hp.register_uri(hp.POST, client.TOKEN_ENDPOINT_URI, body=server_response)

    data = {
        'access_token': 'newaccesstoken',
        'refresh_token': 'newrefreshtoken',
      }
    self.assertNotEqual(client.access_token, data['access_token'])
    self.assertNotEqual(client.refresh_token, data['refresh_token'])
    client.refresh()
    self.assertEqual(client.access_token, data['access_token'])
    self.assertEqual(client.refresh_token, data['refresh_token'])

    def server_response(request, uri, headers):
      return (400, headers, '')
    hp.reset()
    hp.register_uri(hp.POST, client.TOKEN_ENDPOINT_URI, body=server_response)

    client.access_token = access_token
    client.refresh_token = refresh_token
    with self.assertRaises(TokenRefreshError):
      client.refresh()
    self.assertEqual(client.access_token, access_token)
    self.assertEqual(client.refresh_token, refresh_token)
Пример #6
0
  def test_token_endpoint_uri_used_instead_of_default(self):
    # Requests to the default BASE_API_URI will noticeably fail by raising an
    # AssertionError. Requests to the new URL will respond HTTP 200.
    new_token_endpoint_uri = 'http://example.com/oauth/token'

    # If any error is raised by the server, the test suite will never exit when
    # using Python 3. This strange technique is used to raise the errors
    # outside of the mocked server environment.
    errors_in_server = []

    def server_response(request, uri, headers):
      parsed_uri = urlparse(uri)
      parsed_reference = urlparse(new_token_endpoint_uri)
      try:
        self.assertEqual(parsed_uri.scheme, parsed_reference.scheme)
        self.assertEqual(parsed_uri.netloc, parsed_reference.netloc)
        self.assertEqual(parsed_uri.path, parsed_reference.path)
      except AssertionError as e:
        errors_in_server.append(e)
      response = {
          'access_token': 'newaccesstoken',
          'refresh_token': 'newrefreshtoken',
        }
      return (200, headers, json.dumps(response))
    hp.register_uri(hp.POST, OAuthClient.TOKEN_ENDPOINT_URI, body=server_response)
    hp.register_uri(hp.POST, new_token_endpoint_uri, body=server_response)

    client = OAuthClient(client_id, client_secret, access_token, refresh_token)
    with self.assertRaises(AssertionError):
      client.refresh()
      if errors_in_server: raise errors_in_server.pop()

    client2 = OAuthClient(
        client_id,
        client_secret,
        access_token,
        refresh_token,
        token_endpoint_uri=new_token_endpoint_uri)
    self.assertTrue(client2.refresh())
Пример #7
0
    def test_token_endpoint_uri_used_instead_of_default(self):
        # Requests to the default BASE_API_URI will noticeably fail by raising an
        # AssertionError. Requests to the new URL will respond HTTP 200.
        new_token_endpoint_uri = 'http://example.com/oauth/token'

        # If any error is raised by the server, the test suite will never exit when
        # using Python 3. This strange technique is used to raise the errors
        # outside of the mocked server environment.
        errors_in_server = []

        def server_response(request, uri, headers):
            parsed_uri = urlparse(uri)
            parsed_reference = urlparse(new_token_endpoint_uri)
            try:
                self.assertEqual(parsed_uri.scheme, parsed_reference.scheme)
                self.assertEqual(parsed_uri.netloc, parsed_reference.netloc)
                self.assertEqual(parsed_uri.path, parsed_reference.path)
            except AssertionError as e:
                errors_in_server.append(e)
            response = {
                'access_token': 'newaccesstoken',
                'refresh_token': 'newrefreshtoken',
            }
            return (200, headers, json.dumps(response))

        hp.register_uri(hp.POST,
                        OAuthClient.TOKEN_ENDPOINT_URI,
                        body=server_response)
        hp.register_uri(hp.POST, new_token_endpoint_uri, body=server_response)

        client = OAuthClient(client_id, client_secret, access_token,
                             refresh_token)
        with self.assertRaises(AssertionError):
            client.refresh()
            if errors_in_server: raise errors_in_server.pop()

        client2 = OAuthClient(client_id,
                              client_secret,
                              access_token,
                              refresh_token,
                              token_endpoint_uri=new_token_endpoint_uri)
        self.assertTrue(client2.refresh())
Пример #8
0
    def test_send_money(self):
        account = Account(Client(api_key, api_secret))
        account.id = 'fakeaccountid'

        base_kwargs = {
            'to_btc_address': 'some-btc-address',
            'amount': '12.0 BTC',
        }
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount=None,
                          amount_string=None,
                          amount_currency_iso=None)
            account.send_money(**kwargs)
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount='12.0',
                          amount_string=None,
                          amount_currency_iso='USD')
            account.send_money(**kwargs)
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount='12.0',
                          amount_string='12.0',
                          amount_currency_iso=None)
            account.send_money(**kwargs)
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount='12.0',
                          amount_string='12.0',
                          amount_currency_iso='USD')
            account.send_money(**kwargs)
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount=None,
                          amount_string=None,
                          amount_currency_iso='USD')
            account.send_money(**kwargs)
        with self.assertRaises(ValueError):
            kwargs = base_kwargs.copy()
            kwargs.update(amount=None,
                          amount_string='12.0',
                          amount_currency_iso=None)
            account.send_money(**kwargs)

        def server_response(request, uri, headers):
            try:
                req = json.loads(request.body.decode())
            except ValueError:
                raise AssertionError("request body was malformed.")
            tx_data = req.get('transaction')
            self.assertIsInstance(tx_data, dict)
            self.assertEqual(len(tx_data), len(kwargs))
            return (200, headers, json.dumps(data))

        hp.register_uri(hp.POST, re.compile('.*'), body=server_response)

        with self.assertRaises(APIError):
            data = {'success': False, 'transaction': {'id': '1'}}
            kwargs = base_kwargs.copy()
            account.send_money(**kwargs)
        with self.assertRaises(UnexpectedDataFormatError):
            data = {'success': True, 'transaction': 'wrong-type'}
            kwargs = base_kwargs.copy()
            account.send_money(**kwargs)
        with self.assertRaises(UnexpectedDataFormatError):
            data = {'success': True, 'missing-transaction-key': True}
            kwargs = base_kwargs.copy()
            account.send_money(**kwargs)

        data = {'success': True, 'transaction': {'id': '1'}}
        kwargs = base_kwargs.copy()
        tx = account.send_money(**kwargs)
        self.assertIsInstance(tx, Transaction)

        oauth_account = Account(
            OAuthClient(client_id, client_secret, access_token, refresh_token))
        oauth_account.id = 'fakeaccountid'

        hp.reset()

        def server_response(request, uri, headers):
            try:
                req = json.loads(request.body.decode())
            except ValueError:
                raise AssertionError("request body was malformed.")
            tx_data = req.get('transaction')
            self.assertIsInstance(tx_data, dict)
            if two_factor_token:
                self.assertEqual(request.headers.get('CB-2FA-Token'),
                                 two_factor_token)
                self.assertIsNone(tx_data.get('CB-2FA-Token'))
                return (200, headers, json.dumps(data))
            return (402, headers, '')

        hp.register_uri(hp.POST, re.compile('.*'), body=server_response)

        kwargs = base_kwargs.copy()
        kwargs['two_factor_token'] = two_factor_token = None
        with self.assertRaises(TwoFactorTokenRequired):
            oauth_account.send_money(**kwargs)

        kwargs['two_factor_token'] = two_factor_token = 'sometoken'
        tx = oauth_account.send_money(**kwargs)
        self.assertIsInstance(tx, Transaction)
Пример #9
0
    def test_response_handling(self):
        resp200 = lambda r, u, h: (200, h, '')
        resp400 = lambda r, u, h: (400, h, '')
        header_template = (
            'Bearer realm="Doorkeeper" error="{id}" error_description="{error}"'
        )

        def resp401_expired(request, uri, headers):
            error_data = {
                'id': 'invalid_token',
                'error': 'The access token expired',
            }
            headers.update(
                {'www-authenticate': header_template.format(**error_data)})
            return (401, headers, json.dumps(error_data))

        def resp401_invalid(request, uri, headers):
            error_data = {
                'id': 'invalid_token',
                'error': 'The access token is invalid',
            }
            headers.update(
                {'www-authenticate': header_template.format(**error_data)})
            return (401, headers, json.dumps(error_data))

        def resp401_generic(request, uri, headers):
            error_data = {
                'id': 'some_error',
                'error': 'Some description',
            }
            headers.update(
                {'www-authenticate': header_template.format(**error_data)})
            return (401, headers, json.dumps(error_data))

        def resp401_nobody(request, uri, headers):
            return (401, headers, '')

        def resp401_header_expired(request, uri, headers):
            code, headers, _ = resp401_expired(request, uri, headers)
            return (code, headers, '')

        def resp401_header_invalid(request, uri, headers):
            code, headers, _ = resp401_invalid(request, uri, headers)
            return (code, headers, '')

        def resp401_header_generic(request, uri, headers):
            code, headers, _ = resp401_generic(request, uri, headers)
            return (code, headers, '')

        resp402 = lambda r, u, h: (402, h, '')

        hp.register_uri(hp.GET, re.compile('.*200$'), resp200)
        hp.register_uri(hp.GET, re.compile('.*400$'), resp400)
        hp.register_uri(hp.GET, re.compile('.*401_expired$'), resp401_expired)
        hp.register_uri(hp.GET, re.compile('.*401_invalid$'), resp401_invalid)
        hp.register_uri(hp.GET, re.compile('.*401_generic$'), resp401_generic)
        hp.register_uri(hp.GET, re.compile('.*401_nobody$'), resp401_nobody)
        hp.register_uri(hp.GET, re.compile('.*401_header_expired$'),
                        resp401_header_expired)
        hp.register_uri(hp.GET, re.compile('.*401_header_invalid$'),
                        resp401_header_invalid)
        hp.register_uri(hp.GET, re.compile('.*401_header_generic$'),
                        resp401_header_generic)
        hp.register_uri(hp.GET, re.compile('.*402$'), resp402)

        client = OAuthClient(client_id, client_secret, access_token,
                             refresh_token)
        assert client._get('200').status_code == 200
        with self.assertRaises(APIError):
            client._get('400')
        with self.assertRaises(AuthenticationError):
            client._get('401_generic')
        with self.assertRaises(AuthenticationError):
            client._get('401_header_generic')
        with self.assertRaises(InvalidAccessToken):
            client._get('401_invalid')
        with self.assertRaises(InvalidAccessToken):
            client._get('401_header_invalid')
        with self.assertRaises(ExpiredAccessToken):
            client._get('401_expired')
        with self.assertRaises(ExpiredAccessToken):
            client._get('401_header_expired')
        with self.assertRaises(AuthenticationError):
            client._get('401_nobody')
        with self.assertRaises(TwoFactorTokenRequired):
            client._get('402')
Пример #10
0
  def test_response_handling(self):
    resp200 = lambda r, u, h: (200, h, '')
    resp400 = lambda r, u, h: (400, h, '')
    header_template = (
        'Bearer realm="Doorkeeper" error="{id}" error_description="{error}"')
    def resp401_expired(request, uri, headers):
      error_data = {
          'id': 'invalid_token',
          'error': 'The access token expired',
        }
      headers.update({'www-authenticate': header_template.format(**error_data)})
      return (401, headers, json.dumps(error_data))
    def resp401_invalid(request, uri, headers):
      error_data = {
          'id': 'invalid_token',
          'error': 'The access token is invalid',
        }
      headers.update({'www-authenticate': header_template.format(**error_data)})
      return (401, headers, json.dumps(error_data))
    def resp401_generic(request, uri, headers):
      error_data = {
          'id': 'some_error',
          'error': 'Some description',
        }
      headers.update({'www-authenticate': header_template.format(**error_data)})
      return (401, headers, json.dumps(error_data))
    def resp401_nobody(request, uri, headers):
      return (401, headers, '')
    def resp401_header_expired(request, uri, headers):
      code, headers, _ = resp401_expired(request, uri, headers)
      return (code, headers, '')
    def resp401_header_invalid(request, uri, headers):
      code, headers, _ = resp401_invalid(request, uri, headers)
      return (code, headers, '')
    def resp401_header_generic(request, uri, headers):
      code, headers, _ = resp401_generic(request, uri, headers)
      return (code, headers, '')
    resp402 = lambda r, u, h: (402, h, '')

    hp.register_uri(hp.GET, re.compile('.*200$'), resp200)
    hp.register_uri(hp.GET, re.compile('.*400$'), resp400)
    hp.register_uri(hp.GET, re.compile('.*401_expired$'), resp401_expired)
    hp.register_uri(hp.GET, re.compile('.*401_invalid$'), resp401_invalid)
    hp.register_uri(hp.GET, re.compile('.*401_generic$'), resp401_generic)
    hp.register_uri(hp.GET, re.compile('.*401_nobody$'), resp401_nobody)
    hp.register_uri(hp.GET, re.compile('.*401_header_expired$'), resp401_header_expired)
    hp.register_uri(hp.GET, re.compile('.*401_header_invalid$'), resp401_header_invalid)
    hp.register_uri(hp.GET, re.compile('.*401_header_generic$'), resp401_header_generic)
    hp.register_uri(hp.GET, re.compile('.*402$'), resp402)

    client = OAuthClient(client_id, client_secret, access_token, refresh_token)
    assert client._get('200').status_code == 200
    with self.assertRaises(APIError):
      client._get('400')
    with self.assertRaises(AuthenticationError):
      client._get('401_generic')
    with self.assertRaises(AuthenticationError):
      client._get('401_header_generic')
    with self.assertRaises(InvalidAccessToken):
      client._get('401_invalid')
    with self.assertRaises(InvalidAccessToken):
      client._get('401_header_invalid')
    with self.assertRaises(ExpiredAccessToken):
      client._get('401_expired')
    with self.assertRaises(ExpiredAccessToken):
      client._get('401_header_expired')
    with self.assertRaises(AuthenticationError):
      client._get('401_nobody')
    with self.assertRaises(TwoFactorTokenRequired):
      client._get('402')