requests.URLRequired

Here are the examples of the python api requests.URLRequired taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

3 Examples 7

0 Source : device_test.py
with MIT License
from alexmohr

def mocked_requests_post(*args, **kwargs):
    url = args[0]
    print("POST for URL: {}".format(url))
    if not url:
        raise URLRequired()
    elif url == REGISTRATION_URL_V4:
        return MockResponse({}, 200)

    elif url == REGISTRATION_URL_V4_FAIL:
        return MockResponse({"error": 402}, 200)

    elif url == REGISTRATION_URL_V4_FAIL_401:
        MockResponse(None, 401).raise_for_status()

    elif url == SOAP_URL:
        return MockResponse({}, 200, "data")

    elif url == urljoin(BASE_URL, 'system'):
        result = MockResponseJson({"status": "on"})
        return MockResponse({"result": [result]}, 200)

    elif APP_START_URL_LEGACY in url:
        return MockResponse(None, 200)

    elif APP_START_URL in url:
        return MockResponse(None, 200)

    elif url == AV_TRANSPORT_URL:
        return MockResponse(None,
                            200,
                            read_file(
                                'data/playing_status_legacy_playing.xml'))

    elif url == AV_TRANSPORT_URL_NO_MEDIA:
        return MockResponse(None,
                            200,
                            read_file(
                                'data/playing_status_legacy_no_media.xml'))

    elif url == COMMAND_LIST_V4:
        json_data = jsonpickle.decode(read_file('data/commandList.json'))
        return MockResponse(json_data, 200, "")

    elif url == SYSTEM_INFORMATION_URL_V4:
        json_data = jsonpickle.decode(read_file('data/systemInformation.json'))
        return MockResponse(json_data, 200, "")

    elif url.startswith(REQUESTS_ERROR):
        raise RequestException

    else:
        raise ValueError("Unknown url requested: {}".format(url))


def mocked_requests_get(*args, **kwargs):

0 Source : test_deafult_import_resolver.py
with Apache License 2.0
from cloudify-cosmo

    def _test_default_resolver(self, import_url, rules,
                               expected_urls_to_resolve=[],
                               expected_failure=False,
                               partial_err_msg=None,
                               fallback=False):

        urls_to_resolve = []
        number_of_attempts = []

        class mock_requests_get(object):

            def __init__(self, url, timeout):
                self.status_code = 200
                self.text = 200
                number_of_attempts.append(1)
                if url not in urls_to_resolve:
                    urls_to_resolve.append(url)
                if url in [ORIGINAL_V1_URL, ORIGINAL_V2_URL, INVALID_V1_URL]:
                    raise requests.URLRequired(
                        'invalid url: {0}'.format(url))
                elif url == ILLEGAL_URL:
                    raise requests.URLRequired(
                        'unknown url type: {0}'.format(
                            url))
                elif url in [VALID_V1_URL, VALID_V2_URL]:
                    return None
                elif url == TIMEOUT_URL:
                    raise requests.ConnectionError(
                        'Timeout while trying to import')
                elif url == BAD_RESPONSE_CODE_URL:
                    self.status_code = 404
                    self.text = 404
                elif url == RETRY_URL:
                    if len(number_of_attempts)   <   MAX_NUMBER_RETRIES:
                        raise requests.ConnectionError(
                            'Timeout while trying to import')
                    else:
                        return None

        resolver = DefaultImportResolver(rules=rules, fallback=fallback)
        with mock.patch('requests.get', new=mock_requests_get,
                        create=True):
            with mock.patch(
                    'dsl_parser.import_resolver.abstract_import_resolver.'
                    'DEFAULT_RETRY_DELAY', new=RETRY_DELAY):
                try:
                    resolver.resolve(import_url=import_url)
                    if expected_failure:
                        err_msg = 'resolve should have been failed'
                        if partial_err_msg:
                            err_msg = \
                                '{0} with error message that contains: {1}'\
                                .format(err_msg, partial_err_msg)
                        raise AssertionError(err_msg)
                except DSLParsingLogicException as ex:
                    if not expected_failure:
                        raise ex
                    if partial_err_msg:
                        self.assertIn(partial_err_msg, str(ex))

        self.assertEqual(len(expected_urls_to_resolve), len(urls_to_resolve))
        for resolved_url in expected_urls_to_resolve:
            self.assertIn(resolved_url, urls_to_resolve)
        # expected to be 1 initial attempt + 4 retries
        if import_url == RETRY_URL:
            self.assertEqual(MAX_NUMBER_RETRIES, len(number_of_attempts))
        if import_url == TIMEOUT_URL:
            self.assertEqual(MAX_NUMBER_RETRIES + 1, len(number_of_attempts))


class TestDefaultResolverValidations(unittest.TestCase):

0 Source : client.py
with MIT License
from trustpilot

    def setup(
        self,
        api_host=None,
        api_key=None,
        api_version=None,
        api_secret=None,
        username=None,
        password=None,
        access_token=None,
        token_issuer_path=None,
        token_issuer_host=None,
        user_agent=None,
        **kwargs
    ):

        self.api_host = api_host or environ.get(
            "TRUSTPILOT_API_HOST", "https://api.trustpilot.com"
        )

        try:
            self.api_key = api_key or environ["TRUSTPILOT_API_KEY"]
            self.api_secret = api_secret or environ.get("TRUSTPILOT_API_SECRET", "")
            self.username = username or environ.get("TRUSTPILOT_USERNAME")
            self.password = password or environ.get("TRUSTPILOT_PASSWORD")
            self.access_token = access_token
        except KeyError as e:
            logger.debug("Not auth setup, missing env-var or setup for {}".format(e))

        self.api_version = api_version or environ.get("TRUSTPILOT_API_VERSION", "v1")
        self.token_issuer_host = token_issuer_host or self.api_host
        self.access_token = access_token
        self.token_issuer_path = token_issuer_path or environ.get(
            "TRUSTPILOT_API_TOKEN_ISSUER_PATH",
            "oauth/oauth-business-users-for-applications/accesstoken",
        )
        self.hooks = dict()
        self.user_agent = user_agent or environ.get(
            "TRUSTPILOT_USER_AGENT", auth.get_user_agent()
        )

        if not self.api_host.startswith("http"):
            raise requests.URLRequired(
                "'{}' is not a valid api_host url".format(api_host)
            )

        self.hooks["response"] = self._post_request_callback

        return self

    def get_request_auth_headers(self):