def vcr(vcr): def range_header_matcher(r1, r2): return r1.headers.get("Range", "") == r2.headers.get("Range", "") vcr.cassette_library_dir = CASSETTE_DIR vcr.path_transformer = VCR.ensure_suffix(".yaml") vcr.filter_headers = ["Set-Cookie"] vcr.before_record_request = scrub_request vcr.before_record_response = chain( scrub_response, scrub_string(rb"Request done in \S+ seconds.", b"Request done in ... seconds."), scrub_string(rb'"updated":"[^"]+"', b'"updated":"..."'), scrub_string(rb'totalResults":"\d{4,}"', b'totalResults":"10000"'), scrub_string(rb"of \d{4,} total results", b"of 10000 total results"), scrub_string(rb"&start=\d{4,}&rows=0", b"&start=10000&rows=0"), ) vcr.decode_compressed_response = True vcr.register_serializer("custom", BinaryContentSerializer(CASSETTE_DIR)) vcr.serializer = "custom" vcr.register_matcher("range_header", range_header_matcher) vcr.match_on = [ "method", "range_header", "host", "port", "path", "query", "body" ] return vcr
def vcr(vcr): def scrub_request(request): for header in ("Authorization", "Set-Cookie", "Cookie"): if header in request.headers: del request.headers[header] return request def scrub_response(response): for header in ("Authorization", "Set-Cookie", "Cookie", "Date", "Expires", "Transfer-Encoding"): if header in response["headers"]: del response["headers"][header] return response def range_header_matcher(r1, r2): return r1.headers.get('Range', '') == r2.headers.get('Range', '') vcr.cassette_library_dir = CASSETTE_DIR vcr.path_transformer = VCR.ensure_suffix('.yaml') vcr.filter_headers = ['Set-Cookie'] vcr.before_record_request = scrub_request vcr.before_record_response = scrub_response vcr.decode_compressed_response = True vcr.register_serializer('custom', BinaryContentSerializer(CASSETTE_DIR)) vcr.serializer = 'custom' vcr.register_matcher('range_header', range_header_matcher) vcr.match_on = ['uri', 'method', 'body', 'range_header'] return vcr
def vcr(vcr): def scrub_request(request): for header in ("Authorization", "Set-Cookie", "Cookie"): if header in request.headers: del request.headers[header] return request def scrub_response(response): for header in ("Authorization", "Set-Cookie", "Cookie", "Date", "Expires", "Transfer-Encoding"): if header in response["headers"]: del response["headers"][header] return response def range_header_matcher(r1, r2): return r1.headers.get('Range', '') == r2.headers.get('Range', '') vcr.cassette_library_dir = CASSETTE_DIR vcr.path_transformer = VCR.ensure_suffix('.yaml') vcr.filter_headers = ['Set-Cookie'] vcr.before_record_request = scrub_request vcr.before_record_response = scrub_response vcr.decode_compressed_response = True vcr.register_serializer('custom', BinaryContentSerializer(CASSETTE_DIR)) vcr.serializer = 'custom' vcr.register_matcher('range_header', range_header_matcher) vcr.match_on = ['uri', 'method', 'body', 'range_header'] return vcr
def vcr_config(): """VCR configuration.""" return { "cassette_library_dir": "gencove/tests/upload/vcr", "filter_headers": [ "Authorization", "Content-Length", "User-Agent", "X-Amz-Security-Token", "X-Amz-Date", ], "filter_post_data_parameters": [ ("email", "*****@*****.**"), ("password", "mock_password"), ], "filter_query_parameters": [ ("search", "gncv://cli-mock/test.fastq.gz") ], "match_on": ["method", "scheme", "port", "path", "query"], "path_transformer": VCR.ensure_suffix(".yaml"), "before_record_request": [ replace_gencove_url_vcr, filter_upload_request, filter_project_samples_request, ], "before_record_response": [ filter_jwt, filter_upload_credentials_response, filter_upload_post_data_response, filter_volatile_dates, filter_aws_headers, filter_sample_sheet_response, filter_project_samples_response, ], }
def _get_vcr(self, **kwargs): my_vcr = super(GoogleSheetsConfigTestApi, self)._get_vcr(**kwargs) my_vcr.record_mode = 'once' my_vcr.path_transformer = VCR.ensure_suffix('.yaml') my_vcr.cassette_library_dir = os.path.dirname( os.path.abspath(__file__)) + '/vcr/google_sheets/' return my_vcr
def make_vcr(pytestconfig, cassette_library_dir): mode = pytestconfig.getoption('--vcr-mode') api_key = pytestconfig.getoption('--whispir-api-key') username = pytestconfig.getoption('--whispir-username') gcm_api_key = pytestconfig.getoption('--whispir-gcm-api-key') scrubber = scrub_patterns( ((api_key, TEST_API_KEY), (username, TEST_USERNAME), (gcm_api_key, TEST_GCM_API_KEY))) options = { 'record_mode': mode, 'filter_headers': [('authorization', replace_auth), ('set-cookie', None), ('cookie', None), ('User-Agent', None), ('x-api-key', TEST_API_KEY)], 'before_record_response': scrubber, 'before_record_request': scrubber, 'path_transformer': VCR.ensure_suffix('.yaml'), 'decode_compressed_response': True, 'cassette_library_dir': cassette_library_dir, 'match_on': ('method', 'scheme', 'host', 'port', 'path', 'query', 'headers'), 'serializer': 'pretty-yaml' } vcr = VCR(**options) vcr.register_serializer('pretty-yaml', prettyserializer) return vcr
def test_ensure_suffix(): vcr = VCR(inject_cassette=True, path_transformer=VCR.ensure_suffix('.yaml')) @vcr.use_cassette def function_name(cassette): assert cassette._path == os.path.join(os.path.dirname(__file__), 'function_name.yaml') function_name()
def vcr(vcr): def scrub_request(request): for header in ("Authorization", "Set-Cookie", "Cookie"): if header in request.headers: del request.headers[header] return request def scrub_response(response): for header in ( "Authorization", "Set-Cookie", "Cookie", "Date", "Expires", "Transfer-Encoding", ): if header in response["headers"]: del response["headers"][header] return response def range_header_matcher(r1, r2): return r1.headers.get("Range", "") == r2.headers.get("Range", "") vcr.cassette_library_dir = CASSETTE_DIR vcr.path_transformer = VCR.ensure_suffix(".yaml") vcr.filter_headers = ["Set-Cookie"] vcr.before_record_request = scrub_request vcr.before_record_response = scrub_response vcr.decode_compressed_response = True vcr.register_serializer("custom", BinaryContentSerializer(CASSETTE_DIR)) vcr.serializer = "custom" vcr.register_matcher("range_header", range_header_matcher) vcr.match_on = ["uri", "method", "body", "range_header"] return vcr
def vcr_config(): """VCR configuration.""" return { "cassette_library_dir": "gencove/tests/projects/vcr", "filter_headers": [ "Authorization", "Content-Length", "User-Agent", ], "filter_post_data_parameters": [ ("email", "*****@*****.**"), ("password", "mock_password"), ], "match_on": ["method", "scheme", "port", "path", "query"], "path_transformer": VCR.ensure_suffix(".yaml"), "before_record_request": [ replace_gencove_url_vcr, filter_project_delete_samples, ], "before_record_response": [ filter_jwt, filter_volatile_dates, ], }
def vcr_config(): return { "record_mode": "new_episodes", # "once", "cassette_library_dir": "tests/cassettes", "path_transformer": VCR.ensure_suffix(".yaml"), "before_record_request": filter_request, "before_record_response": filter_response, }
def vcr(): return VCR( cassette_library_dir=str( Path(__file__).parent.joinpath("fixtures/cassettes")), decode_compressed_response=True, path_transformer=VCR.ensure_suffix(".yaml"), record_mode="once", filter_headers=["authorization"], )
def test_ensure_suffix(): vcr = VCR(inject_cassette=True, path_transformer=VCR.ensure_suffix('.yaml')) @vcr.use_cassette def function_name(cassette): assert cassette._path == os.path.join(os.path.dirname(__file__), 'function_name.yaml') function_name()
def _get_vcr(self, **kwargs): my_vcr = super(DojoVCRTestCase, self)._get_vcr(**kwargs) my_vcr.record_mode = 'once' my_vcr.path_transformer = VCR.ensure_suffix('.yaml') my_vcr.filter_headers = ['Authorization', 'X-Atlassian-Token'] my_vcr.cassette_library_dir = get_unit_tests_path() + '/vcr/jira/' # filters headers doesn't seem to work for cookies, so use callbacks to filter cookies from being recorded my_vcr.before_record_request = self.before_record_request my_vcr.before_record_response = self.before_record_response return my_vcr
def custom_vcr(): dirname = os.path.dirname(__file__) return VCR(decode_compressed_response=True, cassette_library_dir=os.path.join(dirname, 'fixtures/cassettes'), path_transformer=VCR.ensure_suffix('.yml'), filter_query_parameters=bad_fields, before_record_response=filter_payload, filter_post_data_parameters=bad_fields, match_on=['path', 'method'])
def get_recorder(**kw): defaults = dict( record_mode='once', cassette_library_dir=join(dirname(__file__), 'fixtures/cassettes'), path_transformer=VCR.ensure_suffix('.yaml'), match_on=['method', 'path', 'query'], filter_headers=['Authorization'], decode_compressed_response=True, ) defaults.update(kw) return VCR(**defaults)
def get_recorder(base_path=None, **kw): base_path = base_path or dirname(__file__) defaults = dict( record_mode="once", cassette_library_dir=join(base_path, "fixtures/cassettes"), path_transformer=VCR.ensure_suffix(".yaml"), match_on=["method", "path", "query"], filter_headers=["Authorization"], decode_compressed_response=True, ) defaults.update(kw) return VCR(**defaults)
def _decorate_test(self, test_path): recorder = VCR( before_record_request=self._before_record, record_mode=os.environ.get('VCR_MODE', 'none'), cassette_library_dir=join(test_path, 'fixtures/cassettes'), path_transformer=VCR.ensure_suffix('.yaml'), filter_headers=['Authorization'], ) for test_func in dir(self): if test_func.startswith('test'): setattr(self, test_func, recorder.use_cassette(getattr(self, test_func)))
def vcr(request): defaults = ["method", "scheme", "host", "port", "path", "query"] defaults += request.getfixturevalue("vcr_match_on") # record_mode = {once, new_episodes, none, all} # https://vcrpy.readthedocs.io/en/latest/usage.html#record-modes return VCR( filter_headers=request.getfixturevalue("vcr_headers_filter"), record_mode=os.environ.get("VCR_MODE", "once"), cassette_library_dir="tests/fixtures/vcr", match_on=defaults, path_transformer=VCR.ensure_suffix(".yaml"), )
def vcr(request, vcr_config): """The VCR instance""" kwargs = dict( path_transformer=VCR.ensure_suffix(".yaml"), ) marker = request.node.get_marker('vcr') record_mode = request.config.getoption('--vcr-record-mode') kwargs.update(vcr_config) if marker: kwargs.update(marker.kwargs) if record_mode: kwargs['record_mode'] = record_mode vcr = VCR(**kwargs) return vcr
def build_vcr(path=None, **kwargs): cassette_library_dir = BASE_CASSETTE_LIBRARY_DIR if path: cassette_library_dir += '/' + path settings = dict( serializer='yaml', cassette_library_dir=cassette_library_dir, record_mode='once', inject_cassette=True, path_transformer=VCR.ensure_suffix('.yml'), decode_compressed_response=True, filter_headers=[('authorization', '<AUTHORIZATION-HEADER>')], match_on=['method', 'scheme', 'host', 'port', 'path', 'query', 'body'], ) settings.update(**kwargs) return VCR(**settings)
def __new__(cls, name, bases, members): test_path = members['_test_path'] # decorate test method with the cassette klass = type.__new__(cls, name, bases, members) for name, val in inspect.getmembers(klass, inspect.ismethod): if name.startswith('test'): recorder = VCR( before_record_request=_before_record, record_mode=os.environ.get('VCR_MODE', 'none'), cassette_library_dir=join(test_path, 'fixtures/cassettes'), path_transformer=VCR.ensure_suffix('.yaml'), filter_headers=['Authorization'], ) val = recorder.use_cassette(val) setattr(klass, name, val) return klass
def vcr( request, vcr_config, vcr_cassette_dir, ): """The VCR instance""" if request.config.getoption('--vcr-record-mode'): warnings.warn( "--vcr-record-mode has been deprecated and will be removed in a future " "release. Use --vcr-record instead.", DeprecationWarning) kwargs = dict( cassette_library_dir=vcr_cassette_dir, path_transformer=VCR.ensure_suffix(".yaml"), ) kwargs.update(vcr_config) _update_kwargs(request, kwargs) vcr = VCR(**kwargs) return vcr
def vcr_session(request): """Setup VCR at session-level. Borrowed from python-vcr. """ test_dir = os.path.abspath(os.path.dirname(__file__)) cassette_dir = os.path.join(test_dir, 'cassettes') kwargs = dict(cassette_library_dir=cassette_dir, path_transformer=VCR.ensure_suffix(".yaml")) record_mode = request.config.getoption('--vcr-record') if record_mode: kwargs['record_mode'] = record_mode if request.config.getoption('--disable-vcr'): # Set mode to record but discard all responses to disable both recording and playback kwargs['record_mode'] = 'new_episodes' kwargs['before_record_response'] = lambda *args, **kwargs: None vcr = VCR(**kwargs) yield vcr
def recorder(request): """Generate and start a recorder using a helium.Client.""" cassette_name = '' if request.module is not None: cassette_name += request.module.__name__ + '.' cassette_name += request.function.__name__ recorder = VCR( cassette_library_dir=RECORD_FOLDER, decode_compressed_response=True, path_transformer=VCR.ensure_suffix('.yml'), filter_headers=['Authorization'], match_on=['uri', 'method'], ) cassette = recorder.use_cassette(path=cassette_name) with cassette: yield recorder
def vcr(vcr): def scrub_request(request): for header in ("Authorization", "Set-Cookie", "Cookie"): if header in request.headers: del request.headers[header] return request def scrub_response(response): ignore = set(x.lower() for x in [ "Authorization", "Set-Cookie", "Cookie", "Date", "Expires", ]) for header in list(response["headers"]): if header.lower() in ignore or header.lower().startswith( "access-control"): del response["headers"][header] return response def range_header_matcher(r1, r2): return r1.headers.get("Range", "") == r2.headers.get("Range", "") vcr.cassette_library_dir = CASSETTE_DIR vcr.path_transformer = VCR.ensure_suffix(".yaml") vcr.filter_headers = ["Set-Cookie"] vcr.before_record_request = scrub_request vcr.before_record_response = scrub_response vcr.decode_compressed_response = True vcr.register_serializer("custom", BinaryContentSerializer(CASSETTE_DIR)) vcr.serializer = "custom" vcr.register_matcher("range_header", range_header_matcher) vcr.match_on = [ "method", "range_header", "host", "port", "path", "query", "body" ] return vcr
from sentry_youtrack.configuration import YouTrackConfiguration from unittest import TestCase from vcr import VCR import os vcr = VCR(path_transformer=VCR.ensure_suffix('.yaml'), cassette_library_dir=os.path.join('tests', 'cassettes')) print(os.path.join('tests', 'cassettes')) class TestYouTrackConfiguration(TestCase): def setUp(self): self.url = 'https://youtrack.myjetbrains.com' self.username = '******' self.password = '******' self.invalid_url = 'https://example.youtrack.example' def assert_fields_equal(self, field_names, config): assert sorted([field['name'] for field in config]) == sorted(field_names) def get_field(self, yt_config, field_name): for field in yt_config.config: if field['name'] == field_name: return field return None def test_renders_no_input(self): yt_config = YouTrackConfiguration({}) self.assert_fields_equal(['password', 'url', 'username'], yt_config.config)
Vim�UnDo�('D��'-�Eԕ^͈D�,���*/�v^5��4L self.assertEquals(Decimal("0.000039080000000000"), coin.btc_per_day)+">>>>^���_�����^�b���5�_�����^�b��5�_�%����^�c� ;Sfrom coinmine.coin.services.minerstat.coin_per_day_updater import CoinPerDayUpdater5�_�) ����^�c��(*;, def test_handshake_per_day_update(self):5�_�/ ����^�c��.0;' def test_grin_per_day_update(self):5�_�5 ����^�c��46;M def test_update_skips_update_if_results_missing(self, mocked_per_day_gw):5�_�1!����^�c��02;M self.assertEquals(Decimal("0.453569400000000011"), coin.coin_per_day)�12;5�_� 18����^�c��02;c self.assertEquals(Decimal('0.570524000000000000'"0.453569400000000011"), coin.coin_per_day)5�_� +!����^�c��*,;M self.assertEquals(Decimal("1.218043290399940748"), coin.coin_per_day)�+,;5�_� +8����^�c��*,;c self.assertEquals(Decimal('0.320934000000000000'"1.218043290399940748"), coin.coin_per_day)5�_� +9����^�c��*,;N self.assertEquals(Decimal('0.320934000000000000'"), coin.coin_per_day)5�_� +7����^�c��; from django.test import TestCasefrom decimal import Decimalfrom vcr import VCRfrom pathlib import Pathfrom unittest.mock import patch%from coinmine.coin.models import CoinTfrom coinmine.coin.services.whattomine.coin_per_day_updater import CoinPerDayUpdater my_vcr = VCR(0 path_transformer=VCR.ensure_suffix(".yaml"),J cassette_library_dir="{}/vcr_cassettes".format(Path(__file__).parent), record_mode="once",)'class CoinPerDayUpdaterTests(TestCase): fixtures = ["coins.yaml"] def setUp(self):D # ATTN: if you plan to change hashrate, re-record VCR (once)5 Coin.objects.filter(short_name="hns").update(D estimated_hashrate=60, coin_per_day="0", btc_per_day="0" )6 Coin.objects.filter(short_name="grin").update(E estimated_hashrate=0.6, coin_per_day="0", btc_per_day="0" )H self.coins = Coin.objects.filter(short_name__in=["hns", "grin"]) for coin in self.coins:> self.assertEquals(Decimal("0"), coin.coin_per_day)= self.assertEquals(Decimal("0"), coin.btc_per_day)6 def _get_coin_after_update(self, coin_short_name):9 coin = self.coins.get(short_name=coin_short_name)& CoinPerDayUpdater.update(coin) coin.refresh_from_db() return coin @my_vcr.use_cassette7 def test_whattomine_handshake_per_day_update(self):1 coin = self._get_coin_after_update("hns")M self.assertEquals(Decimal('0.320934000000000000'), coin.coin_per_day)L self.assertEquals(Decimal("0.000048154732464316"), coin.btc_per_day) @my_vcr.use_cassette2 def test_whattomine_grin_per_day_update(self):2 coin = self._get_coin_after_update("grin")M self.assertEquals(Decimal('0.570524000000000000'), coin.coin_per_day)L self.assertEquals(Decimal("0.000052213267406772"), coin.btc_per_day)H @patch("coinmine.coin.apis.minerstat.per_day.PerDayGateway.to_dict")X def test_whattomine_update_skips_update_if_results_missing(self, mocked_per_day_gw): # return empty results+ mocked_per_day_gw.return_value = {}1 coin = self._get_coin_after_update("hns"): self.assertEquals(Decimal("0"), coin.coin_per_day)9 self.assertEquals(Decimal("0"), coin.btc_per_day)5�_� 2"����^�d��13;L self.assertEquals(Decimal("0.000052213267406772"), coin.btc_per_day)�23;5�_� 29����^�d��13;b self.assertEquals(Decimal("'0.000039080000000000'0.000052213267406772"), coin.btc_per_day)5�_�2:����^�d��13;N self.assertEquals(Decimal("'0.000039080000000000'"), coin.btc_per_day)5�_�2"����^�d��13;M self.assertEquals(Decimal("'0.000039080000000000'), coin.btc_per_day)5�_�2!����^�d��13;L self.assertEquals(Decimal('0.000039080000000000'), coin.btc_per_day)�23;5�_�28����^�d��13;b self.assertEquals(Decimal('0.000008000000000000''0.000039080000000000'), coin.btc_per_day)5�_�29����^�d��13;M self.assertEquals(Decimal('0.000008000000000000''), coin.btc_per_day)5�_�27����^�d��; from django.test import TestCasefrom decimal import Decimalfrom vcr import VCRfrom pathlib import Pathfrom unittest.mock import patch%from coinmine.coin.models import CoinTfrom coinmine.coin.services.whattomine.coin_per_day_updater import CoinPerDayUpdater my_vcr = VCR(0 path_transformer=VCR.ensure_suffix(".yaml"),J cassette_library_dir="{}/vcr_cassettes".format(Path(__file__).parent), record_mode="once",)'class CoinPerDayUpdaterTests(TestCase): fixtures = ["coins.yaml"] def setUp(self):D # ATTN: if you plan to change hashrate, re-record VCR (once)5 Coin.objects.filter(short_name="hns").update(D estimated_hashrate=60, coin_per_day="0", btc_per_day="0" )6 Coin.objects.filter(short_name="grin").update(E estimated_hashrate=0.6, coin_per_day="0", btc_per_day="0" )H self.coins = Coin.objects.filter(short_name__in=["hns", "grin"]) for coin in self.coins:> self.assertEquals(Decimal("0"), coin.coin_per_day)= self.assertEquals(Decimal("0"), coin.btc_per_day)6 def _get_coin_after_update(self, coin_short_name):9 coin = self.coins.get(short_name=coin_short_name)& CoinPerDayUpdater.update(coin) coin.refresh_from_db() return coin @my_vcr.use_cassette7 def test_whattomine_handshake_per_day_update(self):1 coin = self._get_coin_after_update("hns")M self.assertEquals(Decimal("0.320934000000000000"), coin.coin_per_day)L self.assertEquals(Decimal("0.000048154732464316"), coin.btc_per_day) @my_vcr.use_cassette2 def test_whattomine_grin_per_day_update(self):2 coin = self._get_coin_after_update("grin")M self.assertEquals(Decimal("0.570524000000000000"), coin.coin_per_day)L self.assertEquals(Decimal('0.000008000000000000'), coin.btc_per_day)H @patch("coinmine.coin.apis.minerstat.per_day.PerDayGateway.to_dict")X def test_whattomine_update_skips_update_if_results_missing(self, mocked_per_day_gw): # return empty results+ mocked_per_day_gw.return_value = {}1 coin = self._get_coin_after_update("hns"): self.assertEquals(Decimal("0"), coin.coin_per_day)9 self.assertEquals(Decimal("0"), coin.btc_per_day)5�_�2!����^�e'�13;L self.assertEquals(Decimal("0.000008000000000000"), coin.btc_per_day)�23;5�_�28����^�e)�13;b self.assertEquals(Decimal('0.000039080000000000'"0.000008000000000000"), coin.btc_per_day)5�_�29����^�e*�13;M self.assertEquals(Decimal('0.000039080000000000'"), coin.btc_per_day)5�_�,!����^�e:�+-;L self.assertEquals(Decimal("0.000048154732464316"), coin.btc_per_day)�,-;5�_�,8����^�e;�+-;b self.assertEquals(Decimal('0.000008000000000000'"0.000048154732464316"), coin.btc_per_day)5�_�,8����^�e<�; from django.test import TestCasefrom decimal import Decimalfrom vcr import VCRfrom pathlib import Pathfrom unittest.mock import patch%from coinmine.coin.models import CoinTfrom coinmine.coin.services.whattomine.coin_per_day_updater import CoinPerDayUpdater my_vcr = VCR(0 path_transformer=VCR.ensure_suffix(".yaml"),J cassette_library_dir="{}/vcr_cassettes".format(Path(__file__).parent), record_mode="once",)'class CoinPerDayUpdaterTests(TestCase): fixtures = ["coins.yaml"] def setUp(self):D # ATTN: if you plan to change hashrate, re-record VCR (once)5 Coin.objects.filter(short_name="hns").update(D estimated_hashrate=60, coin_per_day="0", btc_per_day="0" )6 Coin.objects.filter(short_name="grin").update(E estimated_hashrate=0.6, coin_per_day="0", btc_per_day="0" )H self.coins = Coin.objects.filter(short_name__in=["hns", "grin"]) for coin in self.coins:> self.assertEquals(Decimal("0"), coin.coin_per_day)= self.assertEquals(Decimal("0"), coin.btc_per_day)6 def _get_coin_after_update(self, coin_short_name):9 coin = self.coins.get(short_name=coin_short_name)& CoinPerDayUpdater.update(coin) coin.refresh_from_db() return coin @my_vcr.use_cassette7 def test_whattomine_handshake_per_day_update(self):1 coin = self._get_coin_after_update("hns")M self.assertEquals(Decimal("0.320934000000000000"), coin.coin_per_day)L self.assertEquals(Decimal('0.000008000000000000'), coin.btc_per_day) @my_vcr.use_cassette2 def test_whattomine_grin_per_day_update(self):2 coin = self._get_coin_after_update("grin")M self.assertEquals(Decimal("0.570524000000000000"), coin.coin_per_day)L self.assertEquals(Decimal('0.000039080000000000'), coin.btc_per_day)H @patch("coinmine.coin.apis.minerstat.per_day.PerDayGateway.to_dict")X def test_whattomine_update_skips_update_if_results_missing(self, mocked_per_day_gw): # return empty results+ mocked_per_day_gw.return_value = {}1 coin = self._get_coin_after_update("hns"): self.assertEquals(Decimal("0"), coin.coin_per_day)9 self.assertEquals(Decimal("0"), coin.btc_per_day)5�_�4(����^�eb�35;H @patch("coinmine.coin.apis.minerstat.per_day.PerDayGateway.to_dict")5�_�4����^�ei�35;? @patch("coinmine.coin.apis..per_day.PerDayGateway.to_dict")5�_�!����!&V^�o[� !6 def _get_coin_after_update(self, coin_short_name):9 coin = self.coins.get(short_name=coin_short_name)& CoinPerDayUpdater.update(coin) coin.refresh_from_db() return coin5�_� ����!!V^�ov�Tfrom coinmine.coin.services.whattomine.coin_per_day_updater import CoinPerDayUpdater5�_�! ���� V^�o|� 5� 45�_� "!���� 7V7^�o�� for coin in self.coins:> self.assertEquals(Decimal("0"), coin.coin_per_day)= self.assertEquals(Decimal("0"), coin.btc_per_day)5�_�!#"����7V7^�o��2 �15�_�"$#����7V7^�o��39 TestHelpers._assert_coins_set_to_zero(self.coins)5�_�#%$"����7V7^�p$ �!#31 coin = self._get_coin_after_update("hns")5�_�$&%"1����7V7^�pL�!#3S coin = TestHelpers.get_coin_after_update(self._get_coin_after_update("hns")5�_�%'&"2����7V7^�pM �!#38 coin = TestHelpers.get_coin_after_update(("hns")5�_�&('(0����7V7^�pQ�(*3�()35�_�')((����7V7^�pR�'(2 coin = self._get_coin_after_update("grin")5�_�(*)(5����7V7^�pT�')37 coin = TestHelpers.get_coin_after_update("hns")5�_�)+*10����7V7^�pX�133�1235�_�*,+1����7V7^�pX�011 coin = self._get_coin_after_update("hns")5�_�+-,16����7V7^�p[�0238 coin = TestHelpers.get_coin_after_update("grin")5�_�,.-����7V7^�p� � 38from coinmine.coin.tests.test_helpers import TestHelpers5�_�-/.����7V7^�p��38 TestHelpers.assert_coins_set_to_zero(self.coins)5�_�.0/����7V7^�rK� 3� 35�_�/10 %���� 7V7^�rN� 4Sfrom coinmine.coin.services.minerstat.coin_per_day_updater import CoinPerDayUpdater5�_�021#1���� 7V7^�rU�"$47 coin = TestHelpers.get_coin_after_update("hns")5�_�132)1���� 7V7^�rY�(*48 coin = TestHelpers.get_coin_after_update("grin")5�_�24321���� 7V7^�r]�1347 coin = TestHelpers.get_coin_after_update("hns")5�_�3542B���� 7V7^�r]�4 from django.test import TestCasefrom decimal import Decimalfrom vcr import VCRfrom pathlib import Pathfrom unittest.mock import patch%from coinmine.coin.models import CoinAfrom coinmine.coin.tests.services.test_helpers import TestHelpersTfrom coinmine.coin.services.whattomine.coin_per_day_updater import CoinPerDayUpdater my_vcr = VCR(0 path_transformer=VCR.ensure_suffix(".yaml"),J cassette_library_dir="{}/vcr_cassettes".format(Path(__file__).parent), record_mode="once",)'class CoinPerDayUpdaterTests(TestCase): fixtures = ["coins.yaml"] def setUp(self):D # ATTN: if you plan to change hashrate, re-record VCR (once)5 Coin.objects.filter(short_name="hns").update(D estimated_hashrate=60, coin_per_day="0", btc_per_day="0" )6 Coin.objects.filter(short_name="grin").update(E estimated_hashrate=0.6, coin_per_day="0", btc_per_day="0" )H self.coins = Coin.objects.filter(short_name__in=["hns", "grin"]): TestHelpers().assert_coins_set_to_zero(self.coins) @my_vcr.use_cassette7 def test_whattomine_handshake_per_day_update(self):I coin = TestHelpers.get_coin_after_update(CoinPerDayUpdater,"hns")M self.assertEquals(Decimal("0.320934000000000000"), coin.coin_per_day)L self.assertEquals(Decimal("0.000008000000000000"), coin.btc_per_day) @my_vcr.use_cassette2 def test_whattomine_grin_per_day_update(self):J coin = TestHelpers.get_coin_after_update(CoinPerDayUpdater,"grin")M self.assertEquals(Decimal("0.570524000000000000"), coin.coin_per_day)L self.assertEquals(Decimal("0.000039080000000000"), coin.btc_per_day)I @patch("coinmine.coin.apis.whattomine.per_day.PerDayGateway.to_dict")X def test_whattomine_update_skips_update_if_results_missing(self, mocked_per_day_gw): # return empty results+ mocked_per_day_gw.return_value = {}I coin = TestHelpers.get_coin_after_update(CoinPerDayUpdater,"hns"): self.assertEquals(Decimal("0"), coin.coin_per_day)9 self.assertEquals(Decimal("0"), coin.btc_per_day)5�_�465*"����^���)+4M self.assertEquals(Decimal("0.570524000000000000"), coin.coin_per_day)�*+45�_�576*7����^����)+4a self.assertEquals(Decimal("0.5799810000000000000.570524000000000000"), coin.coin_per_day)5�_�687$"����^����#%4M self.assertEquals(Decimal("0.320934000000000000"), coin.coin_per_day)�$%45�_�798$7����^����#%4a self.assertEquals(Decimal("0.4044660000000000000.320934000000000000"), coin.coin_per_day)5�_�8:9%"����^����$&4L self.assertEquals(Decimal("0.000008000000000000"), coin.btc_per_day)�%&45�_�9;:%7����^����$&4` self.assertEquals(Decimal("0.0000407600000000000.000008000000000000"), coin.btc_per_day)5�_�:<;%"����^����$&4L self.assertEquals(Decimal("0.000040760000000000"), coin.btc_per_day)�%&45�_�;=<%7����^����$&4` self.assertEquals(Decimal("0.0000099500000000000.000040760000000000"), coin.btc_per_day)5�_�<>=+"����^����*,4L self.assertEquals(Decimal("0.000039080000000000"), coin.btc_per_day)�+,45�_�=>+7����^����*,4` self.assertEquals(Decimal("0.0000407600000000000.000039080000000000"), coin.btc_per_day)5�_�,"����^�e9�,-;�+-;b self.assertEquals(Decimal("'0.000008000000000000'0.000048154732464316"), coin.btc_per_day)5��
# -*- coding: utf-8 -*- from __future__ import unicode_literals import logging from nose.tools import eq_ import bot_mock from pyfibot.modules import module_urltitle from utils import check_re import pytest from vcr import VCR my_vcr = VCR( path_transformer=VCR.ensure_suffix(".yaml"), cassette_library_dir="tests/cassettes/", record_mode=pytest.config.getoption("--vcrmode"), ) logging.basicConfig() # you need to initialize logging, otherwise you will not see anything from vcrpy vcr_log = logging.getLogger("vcr") vcr_log.setLevel(logging.DEBUG) @pytest.fixture def botmock(): bot = bot_mock.BotMock() module_urltitle.init(bot) return bot lengh_str_regex = r"\d+(h|m|s)(\d+(m))?(\d+s)?" views_str_regex = r"\d+(\.\d+)?(k|M|Billion|Trillion)?"
from vcr import VCR def before_record_callback(request): """Replace confidential information in the recorded cassettes. - customer:key are replaced with 'X:Y' """ payload = json.loads(request.body) payload['SignRequest']['OptionalInputs']['ClaimedIdentity']['Name'] = 'X:Y' request.body = json.dumps(payload) return request my_vcr = VCR(serializer='json', record_mode='once', cassette_library_dir=join(dirname(__file__), 'cassettes'), path_transformer=VCR.ensure_suffix('.json'), before_record=before_record_callback) def fixture_path(filename): """Build the full path of a fixture file.""" return join(dirname(__file__), 'fixtures', filename) class BaseCase(unittest.TestCase): pass
""" body = request.body if helpers.PY3: body = request.body.decode('utf-8') payload = json.loads(body) payload['SignRequest']['OptionalInputs']['ClaimedIdentity']['Name'] = 'X:Y' request.body = json.dumps(payload) return request my_vcr = VCR( serializer='json', record_mode='once', cassette_library_dir=join(dirname(__file__), 'cassettes'), path_transformer=VCR.ensure_suffix('.json'), before_record=before_record_callback ) if helpers.PY3: my_vcr.register_serializer('json', JSONSerializer) def fixture_path(filename): """Build the full path of a fixture file.""" return join(dirname(__file__), 'fixtures', filename) class BaseCase(unittest.TestCase): pass
def serialize(cassette_dict): cassette_dict["recorded_at"] = datetime.now().isoformat()[:-7] return ( f"{json.dumps(serialize_dict(cassette_dict), sort_keys=True, indent=2)}\n" ) @staticmethod def deserialize(cassette_string): return json.loads(cassette_string) vcr = VCR( before_record_response=filter_access_token, cassette_library_dir="tests/integration/cassettes", match_on=["uri", "method"], path_transformer=VCR.ensure_suffix(".json"), serializer="custom_serializer", ) vcr.register_serializer("custom_serializer", CustomSerializer) vcr.register_persister(CustomPersister) def after_init(func, *args): func(*args) def add_init_hook(original_init): """Wrap an __init__ method to also call some hooks.""" @wraps(original_init) def wrapper(self, *args, **kwargs):
"""Defines all test wide settings and variables""" from os import environ from domaintools import API from vcr import VCR def remove_server(response): response.get('headers', {}).pop('server', None) return response vcr = VCR(before_record_response=remove_server, filter_query_parameters=['api_key', 'api_username'], cassette_library_dir='tests/fixtures/vcr/', path_transformer=VCR.ensure_suffix('.yaml'), record_mode='new_episodes') with vcr.use_cassette('init_user_account'): api = API(environ.get('TEST_USER', 'test_user'), environ.get('TEST_KEY', 'test_key'))
def get_path_transformer(config): if "serializer" in config: suffix = ".{}".format(config["serializer"]) else: suffix = ".yaml" return VCR.ensure_suffix(suffix)
session.server_url = 'http://example.com' return session @pytest.fixture() def session_fixture(): options = copy.deepcopy(Yagocd.DEFAULT_OPTIONS) options['server'] = 'http://local.docker:8153/' return Session( auth=('admin', '12345'), options=options ) my_vcr_object = VCR( path_transformer=VCR.ensure_suffix('.yaml'), cassette_library_dir=os.path.join(tests_dir(), 'fixtures/cassettes'), ) @pytest.fixture() def my_vcr(): return my_vcr_object CONTAINER_NAME = 'yagocd-server' CURRENT_DIR = os.path.dirname(os.path.realpath(__file__)) def pytest_addoption(parser): parser.addoption(
# -*- coding: utf-8 -*- import bot_mock from pyfibot.modules import module_urltitle from utils import check_re import pytest from vcr import VCR my_vcr = VCR( path_transformer=VCR.ensure_suffix(".yaml"), cassette_library_dir="tests/cassettes/", record_mode=pytest.config.getoption("--vcrmode"), ) @pytest.fixture def botmock(): bot = bot_mock.BotMock() module_urltitle.init(bot) return bot length_str_regex = u"\d+(h|m|s)(\d+(m))?(\d+s)?" views_str_regex = u"\d+(\.\d+)?(k|M|Billion|Trillion)?" age_str_regex = u"(FRESH|(\d+(\.\d+)?(y|d) (ago|from now)))" @my_vcr.use_cassette def test_areena_radio(botmock):
def my_vcr(gocd_docker): return VCR( path_transformer=VCR.ensure_suffix('.yaml'), cassette_library_dir=os.path.join(root_cassette_library_dir, gocd_docker), )