# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from web3 import HTTPProvider, Web3
from celoetl.service.eth_service import EthService
from celoetl.service.graph_operations import OutOfBoundsError
from tests.helpers import skip_if_slow_tests_disabled
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2015-07-30', 0, 6911]),
skip_if_slow_tests_disabled(['2015-07-31', 6912, 13774]),
skip_if_slow_tests_disabled(['2017-01-01', 2912407, 2918517]),
skip_if_slow_tests_disabled(['2017-01-02', 2918518, 2924575]),
skip_if_slow_tests_disabled(['2018-06-10', 5761663, 5767303])
])
def test_get_block_range_for_date(date, expected_start_block,
expected_end_block):
eth_service = get_new_eth_service()
parsed_date = parse(date)
blocks = eth_service.get_block_range_for_date(parsed_date)
assert blocks == (expected_start_block, expected_end_block)
@pytest.mark.parametrize("date", [
skip_if_slow_tests_disabled(['2015-07-29']),
from tests.zilliqaetl.helpers import get_zilliqa_api
from blockchainetl_common.thread_local_proxy import ThreadLocalProxy
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_tx_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
@pytest.mark.parametrize("start_block, end_block, resource_group ,provider_type", [
(1001, 1003, 'tx_blocks_without_transactions', 'mock'),
skip_if_slow_tests_disabled([1001, 1003, 'tx_blocks_without_transactions', 'online']),
(692365, 692365, 'tx_blocks_with_transactions', 'mock'),
skip_if_slow_tests_disabled([692365, 692365, 'tx_blocks_with_transactions', 'online']),
(1111, 1111, 'tx_blocks_with_exceptions', 'mock'),
skip_if_slow_tests_disabled([175334, 175334, 'tx_blocks_missing_transactions', 'online']),
])
def test_export_tx_blocks_job(tmpdir, start_block, end_block, resource_group, provider_type):
job = ExportTxBlocksJob(
start_block=start_block,
end_block=end_block,
zilliqa_api=ThreadLocalProxy(
lambda: get_zilliqa_api(
provider_type,
read_resource_lambda=lambda file: read_resource(resource_group, file))),
max_workers=5,
item_exporter=ZilliqaItemExporter(str(tmpdir)),
from tests.iotexetl.helpers import get_iotex_rpc
from blockchainetl_common.thread_local_proxy import ThreadLocalProxy
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_transaction_logs_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
@pytest.mark.parametrize("start_block, end_block, resource_group ,provider_type", [
(5202793, 5202793, 'transaction_logs', 'mock'),
skip_if_slow_tests_disabled([5202793, 5202793, 'transaction_logs', 'online']),
])
def test_export_transaction_logs_job(tmpdir, start_block, end_block, resource_group, provider_type):
job = ExportTransactionLogsJob(
start_block=start_block,
end_block=end_block,
iotex_rpc=ThreadLocalProxy(
lambda: get_iotex_rpc(
provider_type,
read_resource_lambda=lambda file: read_resource(resource_group, file))),
max_workers=5,
item_exporter=IotexItemExporter(str(tmpdir)),
)
job.run()
compare_lines_ignore_order(
from tests.celoetl.job.helpers import get_web3_provider
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_contracts_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
CONTRACT_ADDRESSES_UNDER_TEST = ['0x06012c8cf97bead5deae237070f9587f8e7a266d']
@pytest.mark.parametrize("batch_size,contract_addresses,output_format,resource_group,web3_provider_type", [
(1, CONTRACT_ADDRESSES_UNDER_TEST, 'json', 'erc721_contract', 'mock'),
skip_if_slow_tests_disabled((1, CONTRACT_ADDRESSES_UNDER_TEST, 'json', 'erc721_contract', 'infura'))
])
def test_export_contracts_job(tmpdir, batch_size, contract_addresses, output_format, resource_group,
web3_provider_type):
contracts_output_file = str(tmpdir.join('actual_contracts.' + output_format))
job = ExportContractsJob(
contract_addresses_iterable=contract_addresses,
batch_size=batch_size,
batch_web3_provider=ThreadLocalProxy(
lambda: get_web3_provider(web3_provider_type, lambda file: read_resource(resource_group, file), batch=True)
),
max_workers=5,
item_exporter=contracts_item_exporter(contracts_output_file)
)
job.run()
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, batch_size, resource_group ,provider_type,chain",
[
(50001, 50002, 1, 'bitcoin/stream_50001_50002', 'mock', 'bitcoin'),
skip_if_slow_tests_disabled([
50001, 50002, 1, 'bitcoin/stream_50001_50002', 'online', 'bitcoin'
]),
])
def test_stream(tmpdir, start_block, end_block, batch_size, resource_group,
provider_type, chain):
try:
os.remove('last_synced_block.txt')
except OSError:
pass
blocks_output_file = str(tmpdir.join('actual_block.json'))
transactions_output_file = str(tmpdir.join("actual_transactions.json"))
streamer_adapter = BtcStreamerAdapter(
bitcoin_rpc=ThreadLocalProxy(
lambda: get_bitcoin_rpc(provider_type,
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from blockchainetl_common.graph.graph_operations import OutOfBoundsError
from tests.zilliqaetl.helpers import get_zilliqa_api
from tests.helpers import skip_if_slow_tests_disabled
from zilliqaetl.service.block_range_service import BlockRangeService
from zilliqaetl.service.ds_block_timestamp_graph import DsBlockTimestampGraph
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2019-06-18', 0, 1422]),
skip_if_slow_tests_disabled(['2020-08-01', 7004, 7021]),
])
def test_get_ds_block_range_for_date(date, expected_start_block,
expected_end_block):
block_range_service = get_ds_block_range_service()
parsed_date = parse(date)
blocks = block_range_service.get_block_range_for_date(parsed_date)
assert (expected_start_block, expected_end_block) == blocks
@pytest.mark.parametrize("date", [skip_if_slow_tests_disabled(['2019-06-01'])])
def test_get_ds_block_range_for_date_fail(date):
block_range_service = get_ds_block_range_service()
parsed_date = parse(date)
with pytest.raises(OutOfBoundsError):
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from tezosetl.service.tezos_block_range_service import TezosBlockRangeService
from blockchainetl_common.graph.graph_operations import OutOfBoundsError
from tests.tezosetl.helpers import get_tezos_rpc
from tests.helpers import skip_if_slow_tests_disabled
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2018-06-30', 0, 377]),
skip_if_slow_tests_disabled(['2020-01-01', 760512, 761937]),
])
def test_get_block_range_for_date(date, expected_start_block, expected_end_block):
tezos_block_range_service = get_new_tezos_block_range_service()
parsed_date = parse(date)
blocks = tezos_block_range_service.get_block_range_for_date(parsed_date)
assert (expected_start_block, expected_end_block) == blocks
@pytest.mark.parametrize("date", [
skip_if_slow_tests_disabled(['2030-01-01'])
])
def test_get_block_range_for_date_fail(date):
tezos_service = get_new_tezos_block_range_service()
parsed_date = parse(date)
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, batch_size, resource_group, provider_type, chain",
[
(0, 0, 1, 'bitcoin/block_0', 'mock', 'bitcoin'),
skip_if_slow_tests_disabled(
[0, 0, 1, 'bitcoin/block_0', 'online', 'bitcoin']),
(1, 1, 1, 'bitcoin/block_1', 'mock', 'bitcoin'),
skip_if_slow_tests_disabled(
[1, 1, 1, 'bitcoin/block_1', 'online', 'bitcoin']),
(50000, 50000, 1, 'bitcoin/block_without_transactions', 'mock',
'bitcoin'),
skip_if_slow_tests_disabled([
50000, 50000, 1, 'bitcoin/block_without_transactions', 'online',
'bitcoin'
]),
(50001, 50002, 2, 'bitcoin/block_with_transactions', 'mock',
'bitcoin'),
skip_if_slow_tests_disabled([
50001, 50002, 2, 'bitcoin/block_with_transactions', 'online',
'bitcoin'
]),
RESOURCE_GROUP = 'test_stream'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, batch_size, resource_group, entity_types, provider_type",
[
(1755634, 1755635, 1, 'blocks_1755634_1755635',
EntityType.ALL_FOR_INFURA, 'mock'),
skip_if_slow_tests_disabled([
1755634, 1755635, 1, 'blocks_1755634_1755635',
EntityType.ALL_FOR_INFURA, 'infura'
]),
(508110, 508110, 1, 'blocks_508110_508110',
['trace', 'contract', 'token'], 'mock'),
(2112234, 2112234, 1, 'blocks_2112234_2112234',
['trace', 'contract', 'token'], 'mock'),
])
def test_stream(tmpdir, start_block, end_block, batch_size, resource_group,
entity_types, provider_type):
try:
os.remove('last_synced_block.txt')
except OSError:
pass
blocks_output_file = str(tmpdir.join('actual_blocks.json'))
transactions_output_file = str(tmpdir.join('actual_transactions.json'))
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from eosetl.service.eos_block_range_service import EosBlockRangeService
from blockchainetl_common.graph.graph_operations import OutOfBoundsError
from tests.eosetl.job.helpers import get_eos_rpc
from tests.helpers import skip_if_slow_tests_disabled
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2018-06-08', 1, 1]),
skip_if_slow_tests_disabled(['2018-06-09', 2, 13338]),
skip_if_slow_tests_disabled(['2018-11-01', 24569043, 24741696]),
skip_if_slow_tests_disabled(['2018-11-02', 24741697, 24914090]),
skip_if_slow_tests_disabled(['2019-06-01', 61118944, 61291688]),
])
def test_get_block_range_for_date(date, expected_start_block,
expected_end_block):
eos_block_range_service = get_new_eos_block_range_service()
parsed_date = parse(date)
blocks = eos_block_range_service.get_block_range_for_date(parsed_date)
assert (expected_start_block, expected_end_block) == blocks
@pytest.mark.parametrize("date", [skip_if_slow_tests_disabled(['2030-01-01'])])
def test_get_block_range_for_date_fail(date):
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_ds_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, resource_group ,provider_type", [
(123, 125, 'ds_blocks', 'mock'),
skip_if_slow_tests_disabled([123, 125, 'ds_blocks', 'online']),
])
def test_export_ds_blocks_job(tmpdir, start_block, end_block, resource_group,
provider_type):
job = ExportDsBlocksJob(
start_block=start_block,
end_block=end_block,
zilliqa_api=ThreadLocalProxy(
lambda: get_zilliqa_api(provider_type,
read_resource_lambda=lambda file:
read_resource(resource_group, file))),
max_workers=5,
item_exporter=ZilliqaItemExporter(str(tmpdir)),
)
job.run()
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from iotexetl.service.iotex_block_range_service import IotexBlockRangeService
from blockchainetl_common.graph.graph_operations import OutOfBoundsError
from tests.iotexetl.helpers import get_iotex_rpc
from tests.helpers import skip_if_slow_tests_disabled
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2019-04-22', 1, 7828]),
skip_if_slow_tests_disabled(['2020-07-15', 5908040, 5925317]),
])
def test_get_block_range_for_date(date, expected_start_block,
expected_end_block):
iotex_block_range_service = get_iotex_block_range_service()
parsed_date = parse(date)
blocks = iotex_block_range_service.get_block_range_for_date(parsed_date)
assert (expected_start_block, expected_end_block) == blocks
@pytest.mark.parametrize("date", [skip_if_slow_tests_disabled(['2019-01-01'])])
def test_get_block_range_for_date_fail(date):
iotex_block_range_service = get_iotex_block_range_service()
parsed_date = parse(date)
with pytest.raises(OutOfBoundsError):
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, batch_size, resource_group ,provider_type,chain",
[
(0, 0, 1, 'bitcoin/block_0', 'mock', 'bitcoin'),
skip_if_slow_tests_disabled(
[0, 0, 1, 'bitcoin/block_0', 'online', 'bitcoin']),
(1, 1, 1, 'bitcoin/block_1', 'mock', 'bitcoin'),
skip_if_slow_tests_disabled(
[1, 1, 1, 'bitcoin/block_1', 'online', 'bitcoin']),
(50000, 50000, 1, 'bitcoin/block_without_transactions', 'mock',
'bitcoin'),
skip_if_slow_tests_disabled([
50000, 50000, 1, 'bitcoin/block_without_transactions', 'online',
'bitcoin'
]),
(50001, 50002, 2, 'bitcoin/block_with_transactions', 'mock',
'bitcoin'),
skip_if_slow_tests_disabled([
50001, 50002, 2, 'bitcoin/block_with_transactions', 'online',
'bitcoin'
]),
from tests.eosetl.job.helpers import get_eos_rpc
from blockchainetl.thread_local_proxy import ThreadLocalProxy
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
@pytest.mark.parametrize("start_block, end_block, batch_size, resource_group ,provider_type, chain", [
(1, 1, 1, 'eos/block_1', 'mock', 'eos'),
skip_if_slow_tests_disabled([1, 1, 1, 'eos/block_1', 'online', 'eos'], "eos"),
skip_if_slow_tests_disabled([30000000, 30000000, 1, 'eos/block_30000000', 'online', 'eos'], "eos"),
# (1, 1, 1, 'bitcoin/block_1', 'mock', 'bitcoin'),
# skip_if_slow_tests_disabled([1, 1, 1, 'bitcoin/block_1', 'online', 'bitcoin']),
# (50000, 50000, 1, 'bitcoin/block_without_transactions', 'mock', 'bitcoin'),
# skip_if_slow_tests_disabled([50000, 50000, 1, 'bitcoin/block_without_transactions', 'online', 'bitcoin']),
# (50001, 50002, 2, 'bitcoin/block_with_transactions', 'mock', 'bitcoin'),
# skip_if_slow_tests_disabled([50001, 50002, 2, 'bitcoin/block_with_transactions', 'online', 'bitcoin']),
# (2, 2, 1, 'dogecoin/block_without_transactions', 'mock', 'dogecoin'),
# skip_if_slow_tests_disabled([107212, 107212, 1, 'dogecoin/block_with_float_precision_loss', 'online', 'dogecoin'],
# chain='dogecoin'),
# (0, 0, 1, 'zcash/block_0', 'mock', 'zcash'),
# skip_if_slow_tests_disabled([0, 0, 1, 'zcash/block_0', 'online', 'zcash'],
# chain='zcash'),
# (508, 508, 1, 'zcash/block_with_shielded_addresses', 'mock', 'zcash'),
# skip_if_slow_tests_disabled([508, 508, 1, 'zcash/block_with_shielded_addresses', 'online', 'zcash'],
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, resource_group ,provider_type", [
(3290498, 3290498, 'blocks_with_actions', 'mock'),
skip_if_slow_tests_disabled(
[3290498, 3290498, 'blocks_with_actions', 'online']),
(5728441, 5728441, 'blocks_with_execution', 'mock'),
skip_if_slow_tests_disabled(
[5728441, 5728441, 'blocks_with_execution', 'online']),
(5914081, 5914081, 'blocks_with_put_poll_result', 'mock'),
skip_if_slow_tests_disabled(
[5914081, 5914081, 'blocks_with_put_poll_result', 'online']),
(5908046, 5908046, 'blocks_with_claim_from_rewarding_fund', 'mock'),
skip_if_slow_tests_disabled([
5908046, 5908046, 'blocks_with_claim_from_rewarding_fund', 'online'
]),
(5911020, 5911020, 'blocks_with_stake_create', 'mock'),
skip_if_slow_tests_disabled(
[5911020, 5911020, 'blocks_with_stake_create', 'online']),
])
def test_export_blocks_job(tmpdir, start_block, end_block, resource_group,
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
DEFAULT_TX_HASHES = ['0x04cbcb236043d8fb7839e07bbc7f5eed692fb2ca55d897f1101eac3e3ad4fab8',
'0x463d53f0ad57677a3b430a007c1c31d15d62c37fab5eee598551697c297c235c',
'0x05287a561f218418892ab053adfb3d919860988b19458c570c5c30f51c146f02',
'0xcea6f89720cc1d2f46cc7a935463ae0b99dd5fad9c91bb7357de5421511cee49']
@pytest.mark.parametrize("batch_size,transaction_hashes,output_format,resource_group,web3_provider_type", [
(1, DEFAULT_TX_HASHES, 'csv', 'receipts_with_logs', 'mock'),
(2, DEFAULT_TX_HASHES, 'csv', 'receipts_with_logs', 'mock'),
(2, DEFAULT_TX_HASHES, 'json', 'receipts_with_logs', 'mock'),
skip_if_slow_tests_disabled((1, DEFAULT_TX_HASHES, 'csv', 'receipts_with_logs', 'infura')),
skip_if_slow_tests_disabled((2, DEFAULT_TX_HASHES, 'json', 'receipts_with_logs', 'infura'))
])
def test_export_receipts_job(tmpdir, batch_size, transaction_hashes, output_format, resource_group, web3_provider_type):
receipts_output_file = str(tmpdir.join('actual_receipts.' + output_format))
logs_output_file = str(tmpdir.join('actual_logs.' + output_format))
job = ExportReceiptsJob(
transaction_hashes_iterable=transaction_hashes,
batch_size=batch_size,
batch_web3_provider=ThreadLocalProxy(
lambda: get_web3_provider(web3_provider_type, lambda file: read_resource(resource_group, file), batch=True)
),
max_workers=5,
item_exporter=receipts_and_logs_item_exporter(receipts_output_file, logs_output_file),
export_receipts=receipts_output_file is not None,
RESOURCE_GROUP = 'test_export_tokens_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"token_addresses,resource_group,web3_provider_type",
[(['0xf763be8b3263c268e9789abfb3934564a7b80054'
], 'token_with_invalid_data', 'mock'),
(['0x86fa049857e0209aa7d9e616f7eb3b3b78ecfdb0'
], 'token_with_alternative_return_type', 'mock'),
skip_if_slow_tests_disabled(
(['0x86fa049857e0209aa7d9e616f7eb3b3b78ecfdb0'
], 'token_with_alternative_return_type', 'infura'))])
def test_export_tokens_job(tmpdir, token_addresses, resource_group,
web3_provider_type):
output_file = str(tmpdir.join('tokens.csv'))
job = ExportTokensJob(
token_addresses_iterable=token_addresses,
web3=ThreadLocalProxy(lambda: Web3(
get_web3_provider(web3_provider_type, lambda file: read_resource(
resource_group, file)))),
item_exporter=tokens_item_exporter(output_file),
max_workers=5)
job.run()
compare_lines_ignore_order(
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from eosetl.service.btc_block_range_service import BtcBlockRangeService
from blockchainetl.service.graph_operations import OutOfBoundsError
from tests.eosetl.job.helpers import get_eos_rpc
from tests.helpers import skip_if_slow_tests_disabled
@pytest.mark.parametrize("chain,date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['bitcoin', '2009-01-03', 0, 0], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-01-09', 1, 14], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-03-01', 5924, 6028], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-05-06', 13448, 13582], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-05-07', 13583, 13704], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-05-08', 13705, 13811], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2009-06-05', 16534, 16563], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2013-10-09', 262452, 262645], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2014-04-18', 296393, 296552], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2014-04-19', 296553, 296711], chain='bitcoin'),
skip_if_slow_tests_disabled(['bitcoin', '2017-01-02', 446189, 446347], chain='bitcoin'),
skip_if_slow_tests_disabled(['dogecoin', '2014-01-20', 63869, 65347], chain='dogecoin'),
skip_if_slow_tests_disabled(['dogecoin', '2014-01-21', 65322, 66853], chain='dogecoin'),
skip_if_slow_tests_disabled(['litecoin', '2011-10-07', 0, 0], chain='litecoin'),
skip_if_slow_tests_disabled(['dash', '2014-01-19', 0, 4138], chain='dash'),
skip_if_slow_tests_disabled(['zcash', '2016-10-28', 0, 629], chain='zcash'),
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import pytest
from dateutil.parser import parse
from blockchainetl_common.graph.graph_operations import OutOfBoundsError
from tests.zilliqaetl.helpers import get_zilliqa_api
from tests.helpers import skip_if_slow_tests_disabled
from zilliqaetl.service.block_range_service import BlockRangeService
from zilliqaetl.service.tx_block_timestamp_graph import TxBlockTimestampGraph
@pytest.mark.parametrize("date,expected_start_block,expected_end_block", [
skip_if_slow_tests_disabled(['2019-06-18', 0, 142160]),
skip_if_slow_tests_disabled(['2020-08-01', 700286, 702099]),
])
def test_get_tx_block_range_for_date(date, expected_start_block, expected_end_block):
block_range_service = get_tx_block_range_service()
parsed_date = parse(date)
blocks = block_range_service.get_block_range_for_date(parsed_date)
assert (expected_start_block, expected_end_block) == blocks
@pytest.mark.parametrize("date", [
skip_if_slow_tests_disabled(['2019-06-01'])
])
def test_get_tx_block_range_for_date_fail(date):
block_range_service = get_tx_block_range_service()
parsed_date = parse(date)
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block,end_block,batch_size,resource_group,web3_provider_type", [
(0, 0, 1, 'block_without_transactions', 'mock'),
(483920, 483920, 1, 'block_with_logs', 'mock'),
(47218, 47219, 1, 'blocks_with_transactions', 'mock'),
(47218, 47219, 2, 'blocks_with_transactions', 'mock'),
skip_if_slow_tests_disabled(
(0, 0, 1, 'block_without_transactions', 'infura')),
skip_if_slow_tests_disabled(
(483920, 483920, 1, 'block_with_logs', 'infura')),
skip_if_slow_tests_disabled(
(47218, 47219, 2, 'blocks_with_transactions', 'infura')),
])
def test_export_blocks_job(tmpdir, start_block, end_block, batch_size,
resource_group, web3_provider_type):
blocks_output_file = str(tmpdir.join('actual_blocks.csv'))
transactions_output_file = str(tmpdir.join('actual_transactions.csv'))
job = ExportBlocksJob(
start_block=start_block,
end_block=end_block,
batch_size=batch_size,
batch_web3_provider=ThreadLocalProxy(lambda: get_web3_provider(
from tests.eosetl.job.helpers import get_eos_rpc
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_blocks_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.timeout(10)
@pytest.mark.parametrize(
"start_block, end_block, batch_size, resource_group ,provider_type", [
(5000001, 5000002, 1, 'eos/stream_50001_50002', 'mock'),
skip_if_slow_tests_disabled(
[5000001, 5000002, 1, 'eos/stream_50001_50002', 'online']),
])
def test_stream(tmpdir, start_block, end_block, batch_size, resource_group,
provider_type):
try:
os.remove('last_synced_block.txt')
except OSError:
pass
blocks_output_file = str(tmpdir.join('actual_block.json'))
transactions_output_file = str(tmpdir.join("actual_transactions.json"))
actions_output_file = str(tmpdir.join("actual_actions.json"))
streamer_adapter = EosStreamerAdapter(
eos_rpc=ThreadLocalProxy(
lambda: get_eos_rpc(provider_type,
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
from ethereumetl.jobs.export_origin_job import ExportOriginJob
from ethereumetl.jobs.exporters.origin_exporter import origin_marketplace_listing_item_exporter, origin_shop_product_item_exporter
from ethereumetl.ipfs.origin import get_origin_ipfs_client
from ethereumetl.thread_local_proxy import ThreadLocalProxy
RESOURCE_GROUP = 'test_export_origin_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group], file_name)
@pytest.mark.parametrize("start_block,end_block,batch_size,output_format,resource_group,web3_provider_type,ipfs_client_type", [
(10014847, 10014847, 1, 'json', 'blocks_with_logs', 'mock', 'mock'),
skip_if_slow_tests_disabled((10014847, 10014847, 1, 'json', 'blocks_with_logs', 'infura', 'ipfs'))
])
def test_export_origin(tmpdir, start_block, end_block, batch_size, output_format, resource_group, web3_provider_type, ipfs_client_type):
marketplace_output_file = str(tmpdir.join('actual_marketplace.' + output_format))
shop_output_file = str(tmpdir.join('actual_shop.' + output_format))
ipfs_client = MockIpfsClient(lambda file: read_resource(resource_group, file)) if ipfs_client_type == 'mock' else get_origin_ipfs_client()
job = ExportOriginJob(
start_block=start_block,
end_block=end_block,
batch_size=batch_size,
web3=ThreadLocalProxy(
lambda: Web3(get_web3_provider(web3_provider_type, lambda file: read_resource(resource_group, file)))
),
ipfs_client=ipfs_client,
import tests.resources
from tests.helpers import compare_lines_ignore_order, read_file, skip_if_slow_tests_disabled
RESOURCE_GROUP = 'test_export_job'
def read_resource(resource_group, file_name):
return tests.resources.read_resource([RESOURCE_GROUP, resource_group],
file_name)
@pytest.mark.parametrize(
"start_block, end_block, resource_group ,provider_type", [
(417645, 417645, 'tezos/block_417645', 'mock'),
skip_if_slow_tests_disabled(
[417645, 417645, 'tezos/block_417645', 'online']),
(889027, 889027, 'tezos/block_889027', 'mock'),
skip_if_slow_tests_disabled(
[889027, 889027, 'tezos/block_889027', 'online']),
(979686, 979686, 'tezos/block_979686', 'mock'),
skip_if_slow_tests_disabled(
[979686, 979686, 'tezos/block_979686', 'online']),
])
def test_export_job(tmpdir, start_block, end_block, resource_group,
provider_type):
job = ExportJob(
start_block=start_block,
end_block=end_block,
tezos_rpc=ThreadLocalProxy(
lambda: get_tezos_rpc(provider_type,
read_resource_lambda=lambda file:
