def test_app_expired_header_etag(self, urlopen_mock): @httmock.all_requests def check_etag(url, request): self.assertEqual( request.headers.get('If-None-Match'), '"esipyetag"') return httmock.response( headers={ 'Expires': make_expire_time_str(), 'Etag': '"esipyetag"' }, status_code=304) cache = DictCache() with httmock.HTTMock(*_swagger_spec_mock_): urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) self.assertEqual(len(cache._dict), 0) app = EsiApp( cache_time=None, cache=cache, cache_prefix='esipy_test') self.assertEqual(len(cache._dict), 1) cache.get( app.esi_meta_cache_key )[1]['expires'] = make_expired_time_str() cached_app = cache.get(app.esi_meta_cache_key)[0] with httmock.HTTMock(check_etag): urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) esiapp = EsiApp( cache_time=None, cache=cache, cache_prefix='esipy_test') self.assertEqual(cached_app, esiapp.app) urlopen_mock.return_value.close()
class TestDictCache(BaseTest): """ DictCache test class """ def setUp(self): self.c = DictCache() self.c.set(*self.ex_str) self.c.set(*self.ex_int) self.c.set(*self.ex_cpx) def test_dict_cache_set(self): self.assertEqual(self.c._dict[self.ex_str[0]][0], self.ex_str[1]) self.assertEqual(self.c._dict[self.ex_int[0]][0], self.ex_int[1]) self.assertEqual(self.c._dict[self.ex_cpx[0]][0], self.ex_cpx[1]) def test_dict_cache_get(self): self.check_complex(self.c.get(self.ex_cpx[0])) def test_dict_cache_invalidate(self): self.c.invalidate(self.ex_cpx[0]) self.assertIsNone(self.c.get(self.ex_cpx[0])) def test_dict_cache_expiry(self): self.check_complex(self.c.get(self.ex_cpx[0])) self.c._dict[self.ex_cpx[0]] = (self.ex_cpx[1], time.time() - 1) self.assertIsNone(self.c.get(self.ex_cpx[0])) self.assertNotIn(self.ex_cpx[0], self.c._dict)
def test_app_invalid_cache_value(self, urlopen_mock): cache = DictCache() cache.set(self.app.esi_meta_cache_key, 'somerandomvalue') urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) with httmock.HTTMock(*_swagger_spec_mock_): EsiApp(cache_prefix='esipy_test', cache=cache) self.assertNotEqual(cache.get(self.app.esi_meta_cache_key), 'somerandomvalue')
def test_app_expired_header_no_etag(self, urlopen_mock): cache = DictCache() with httmock.HTTMock(*_swagger_spec_mock_): urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) app = EsiApp( cache_time=None, cache=cache, cache_prefix='esipy_test') urlopen_mock.return_value = open(TestEsiApp.ESI_V1_SWAGGER) appv1 = app.get_v1_swagger cache.get(self.ESI_V1_CACHE_KEY)[1]['Expires'] = None urlopen_mock.return_value = open(TestEsiApp.ESI_V1_SWAGGER) appv1_uncached = app.get_v1_swagger self.assertNotEqual(appv1, appv1_uncached)
def initialize_esi_client(refresh_token=None): """ Retrieves a public or authorized ESI client. Args: auth_id (optional): refresh_token of the user whose client we want to retrieve. By default, a public ESI client is returned. Returns: esi_client (EsiClient): Client object from esipy. """ auth = EsiSecurity( headers={'User-Agent': client_name}, redirect_uri='https://localhost/callback', client_id=client_id, secret_key=secret_key, ) if refresh_token is not None: auth.refresh_token = refresh_token esi_client = EsiClient( auth, retry_requests=True, cache=DictCache(), headers={'User-Agent': client_name}, ) return esi_client
def config_esi_cache(cache_url): """Configure ESI cache backend Args: cache_url (string): diskcache or redis url Returns: cache: esipy.cache >>> config_esi_cache('diskcache:/tmp/esipy-diskcache') # doctest: +ELLIPSIS <esipy.cache.FileCache object at 0x...> >>> config_esi_cache('redis://*****:*****@127.0.0.1:6379/') # doctest: +ELLIPSIS <esipy.cache.RedisCache object at 0x...> """ cache = DictCache() if cache_url: cache_url = urlparse(cache_url) if cache_url.scheme == 'diskcache': from esipy.cache import FileCache filename = cache_url.path cache = FileCache(path=filename) elif cache_url.scheme == 'redis': from esipy.cache import RedisCache import redis redis_server = cache_url.hostname redis_port = cache_url.port redis_client = redis.Redis(host=redis_server, port=redis_port) cache = RedisCache(redis_client) return cache
def test_app_valid_header_etag(self, urlopen_mock): @httmock.all_requests def fail_if_request(url, request): self.fail('Cached data is not supposed to do requests') cache = DictCache() with httmock.HTTMock(*_swagger_spec_mock_): urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) EsiApp(cache_time=None, cache=cache, cache_prefix='esipy_test') with httmock.HTTMock(fail_if_request): urlopen_mock.return_value = open(TestEsiApp.ESI_META_SWAGGER) EsiApp(cache_time=None, cache=cache, cache_prefix='esipy_test') urlopen_mock.return_value.close()
def setUp(self, urlopen_mock): # I hate those mock... thx urlopen instead of requests... urlopen_mock.return_value = open('test/resources/swagger.json') self.app = App.create('https://esi.tech.ccp.is/latest/swagger.json') self.security = EsiSecurity( app=self.app, redirect_uri=TestEsiPy.CALLBACK_URI, client_id=TestEsiPy.CLIENT_ID, secret_key=TestEsiPy.SECRET_KEY, ) self.cache = DictCache() self.client = EsiClient(self.security, cache=self.cache) self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def __init__(self, security=None, **kwargs): """ Init the ESI client object :param security: (optional) the security object [default: None] :param headers: (optional) additional headers we want to add :param transport_adapter: (optional) an HTTPAdapter object / implement :param cache: (optional) esipy.cache.BaseCache cache implementation. :param raw_body_only: (optional) default value [False] for all requests """ super(EsiClient, self).__init__(security) # lets get rid of all our kwargs headers = kwargs.pop('headers', {}) transport_adapter = kwargs.pop('transport_adapter', None) # initiate the cache object if 'cache' not in kwargs: self.cache = DictCache() else: cache = kwargs.pop('cache') if isinstance(cache, BaseCache): self.cache = cache elif cache is None: self.cache = DummyCache() else: raise ValueError('Provided cache must implement BaseCache') # store default raw_body_only in case user never want parsing self.raw_body_only = kwargs.pop('raw_body_only', False) self.timeout = kwargs.pop('timeout', 10) self.security = security self._session = Session() # check for specified headers and update session.headers if 'User-Agent' not in headers: headers['User-Agent'] = ('EsiPy/Client - ' 'https://github.com/Kyria/EsiPy') self._session.headers.update({"Accept": "application/json"}) self._session.headers.update(headers) # transport adapter if isinstance(transport_adapter, HTTPAdapter): self._session.mount('http://', transport_adapter) self._session.mount('https://', transport_adapter)
def setUp(self, urlopen_mock): # I hate those mock... thx urlopen instead of requests... urlopen_mock.return_value = open('test/resources/swagger.json') warnings.simplefilter('ignore') self.app = App.create('https://esi.evetech.net/latest/swagger.json') with open(TestEsiPy.RSC_SSO_ENDPOINTS, 'r') as sso_endpoints: with open(TestEsiPy.RSC_JWKS, "r") as jwks: self.security = EsiSecurity( app=self.app, redirect_uri=TestEsiPy.CALLBACK_URI, client_id=TestEsiPy.CLIENT_ID, secret_key=TestEsiPy.SECRET_KEY, sso_endpoints=json.load(sso_endpoints), jwks_key=json.load(jwks)) self.cache = DictCache() self.client = EsiClient(self.security, cache=self.cache) self.client_no_auth = EsiClient(cache=self.cache, retry_requests=True)
def setup_esi(app_id, app_secret, refresh_token, cache=DictCache()): """Set up the ESI client Args: app_id (string): SSO Application ID from CCP app_secret (string): SSO Application Secret from CCP refresh_token (string): SSO refresh token cache (False, optional): esipy.cache instance Returns: tuple: esi app definition, esi client >>> setup_esi(CONFIG['SSO_APP_ID'], CONFIG['SSO_APP_KEY'], ... CONFIG['SSO_REFRESH_TOKEN'], cache) # doctest: +ELLIPSIS (<pyswagger.core.App object ...>, <esipy.client.EsiClient object ...>) """ esi_meta = EsiApp(cache=cache) esi = esi_meta.get_latest_swagger esi_security = EsiSecurity( redirect_uri='http://localhost', client_id=app_id, secret_key=app_secret, headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'}) esi_security.update_token({ 'access_token': '', 'expires_in': -1, 'refresh_token': refresh_token }) esi_client = EsiClient( retry_requests=True, headers={'User-Agent': 'https://github.com/eve-n0rman/structurebot'}, raw_body_only=False, security=esi_security, cache=cache) return (esi, esi_client, esi_security)
def setUp(self): self.c = DictCache() self.c.set(*self.ex_str) self.c.set(*self.ex_int) self.c.set(*self.ex_cpx)
def test_esipy_client_with_cache(self): cache = DictCache() client_with_cache = EsiClient(cache=cache) self.assertTrue(isinstance(client_with_cache.cache, BaseCache)) self.assertEqual(client_with_cache.cache, cache)
class TestDictCache(BaseTest): """ DictCache test class """ def setUp(self): self.c = DictCache() self.c.set(*self.ex_str) self.c.set(*self.ex_int) self.c.set(*self.ex_cpx) def tearDown(self): self.c.invalidate(self.ex_str[0]) self.c.invalidate(self.ex_int[0]) self.c.invalidate(self.ex_cpx[0]) def test_dict_cache_set(self): self.assertEqual(self.c._dict[self.ex_str[0]], self.ex_str[1]) self.assertEqual(self.c._dict[self.ex_int[0]], self.ex_int[1]) self.assertEqual(self.c._dict[self.ex_cpx[0]], self.ex_cpx[1]) def test_dict_cache_get(self): self.check_complex(self.c.get(self.ex_cpx[0])) def test_dict_cache_invalidate(self): self.c.invalidate(self.ex_cpx[0]) self.assertIsNone(self.c.get(self.ex_cpx[0])) def test_dict_cache_clear(self): self.assertEqual(self.c._dict[self.ex_str[0]], self.ex_str[1]) self.assertEqual(len(self.c._dict), 3) self.c.clear() self.assertEqual(len(self.c._dict), 0)