import cgi

import functools

import io

import urllib.request

import urllib.parse

class FileCache:

    def __init__(self, dir_path, filename_pattern):

        self.dir_path = dir_path

        self.pattern = filename_pattern

    def historical(self, date, base):

        path = self.dir_path / self.pattern.format(date=date.isoformat(), base=base)

        try:

            return path.open()

        except FileNotFoundError as error:

class OXRAPIRequest:

    DEFAULT_API_ROOT = 'https://openexchangerates.org/api/'

    DEFAULT_RESPONSE_ENCODING = 'utf-8'

    def __init__(self, app_id, api_root=None, *, open_func=urllib.request.urlopen):

        self.api_root = self.DEFAULT_API_ROOT if api_root is None else api_root

        self.app_id = app_id

        self.open_url = open_func

    def _get_response_encoding(self, response, default=None):

    def _raw_query(self, url_tail, params):

        url = '{}?{}'.format(

            urllib.parse.urljoin(self.api_root, url_tail),

            urllib.parse.urlencode(params),

        )

        response = self.open_url(url)

        status_code = response.status

        encoding = self._get_response_encoding(response)

        response_body = io.TextIOWrapper(response, encoding=encoding)

        if 200 <= status_code < 203:

            return response_body

        elif status_code == 404 or status_code == 410:

        elif status_code >= 500:

        else:

        with response_body:

            raise exc_class(url, response_body.read(64 * 1024))

    def historical(self, date, base):

        return self._raw_query(

            'historical/{}.json'.format(date.isoformat()),

            {'app_id': self.app_id, 'base': base},

        )

class LoaderChain:

    def __init__(self):

    def add_loader(self, loader):

        self.loaders.append(loader)

    def _wrap_load_method(orig_func):

        @functools.wraps(orig_func)

        def load_wrapper(self, *args, **kwargs):

            self.used_loader = None

            error = None

            for loader in self.loaders:

                try:

                    response = getattr(loader, orig_func.__name__)(*args, **kwargs)

                    error = this_error

                else:

                    self.used_loader = loader

                    return response

            else:

        return load_wrapper

    @_wrap_load_method

    def historical(self, date, base):

        pass

import datetime

import pathlib

import pytest

from . import relpath

import oxrlib.loaders

CACHE_PATH = relpath('filecache')

CACHE_PATTERN = '{date}_{base}_cache.json'

@pytest.fixture

def dummycache():

    return oxrlib.loaders.FileCache(CACHE_PATH, CACHE_PATTERN)

@pytest.mark.parametrize('date,base', [

    (datetime.date(1999, 2, 1), 'USD'),

    (datetime.date(1999, 3, 1), 'EUR'),

def test_cache_success(dummycache, date, base):

    expect_name = CACHE_PATH / CACHE_PATTERN.format(date=date.isoformat(), base=base)

    with dummycache.historical(date, base) as cache_file:

        assert pathlib.Path(cache_file.name) == expect_name

@pytest.mark.parametrize('date,base', [

    (datetime.date(1999, 2, 1), 'EUR'),

    (datetime.date(1999, 3, 1), 'USD'),

])

def test_cache_not_found(dummycache, date, base):

    try:

        cache_file = dummycache.historical(date, base)

        pass

    else:

        cache_file.close()

        assert False, "cache file found when unexpected"

import io

import pytest

import oxrlib.loaders

from . import any_date

SUCCESS_S = '"success"\n'

class FakeLoader:

    def __init__(self, result):

        self.result = result

    def _respond(self, *args, **kwargs):

        return io.StringIO(self.result)

    def __getattr__(self, name):

        return self._respond

@pytest.fixture

def good_loader():

    return FakeLoader(SUCCESS_S)

@pytest.fixture

def error_loader():

    return FakeErrorLoader(ERROR)

def test_no_loaders(lchain, any_date):

    try:

        lchain.historical(any_date, 'USD')

        pass

    else:

        assert False, "expected NoLoadersError not raised"

def test_one_with_success(lchain, any_date, good_loader):

    lchain.add_loader(good_loader)

    response = lchain.historical(any_date, 'USD')

    assert response.read(32) == SUCCESS_S

def test_two_with_success(lchain, any_date, good_loader, error_loader):

    lchain.add_loader(error_loader)

    lchain.add_loader(good_loader)

import http.client

import io

import json

import os

import random

import string

import urllib.parse

import pytest

import oxrlib.loaders

from . import any_date

APPID_CHARS = string.ascii_letters + string.digits

RANDOM_APPID = ''.join(random.choice(APPID_CHARS) for _ in range(32))

API_ROOT = 'http://[100::]/oxrlibtest/'

API_ROOT_PATH = urllib.parse.urlsplit(API_ROOT).path

class FakeResponse:

    debuglevel = 0

    version = 11

    body = "Good Test"

    opener = FakeOpener(FakeResponse(200, body))

    api_client.open_url = opener

    response = api_client.historical(any_date, base)

    assert opener.call_count() == 1

    urlparts = urllib.parse.urlsplit(opener.last_called_url())

    assert urlparts.path == '{}historical/{}.json'.format(API_ROOT_PATH, any_date.isoformat())

    params = urllib.parse.parse_qs(urlparts.query)

    assert params['base'] == [base]

    assert response.read() == (json.dumps(body) + "\n")

@pytest.mark.parametrize('status_code,expect_exctype', [

])

def test_failure(api_client, any_date, status_code, expect_exctype):

    opener = FakeOpener(FakeResponse(status_code))

    api_client.open_url = opener

    try:

        response = api_client.historical(any_date, 'USD')

    except expect_exctype:

        pass

    else:

        assert False, "got response: " + response.read()