def test_save_compatibility_statuses_self(self):
packages = [PACKAGE_1]
status = compatibility_store.Status.SUCCESS
comp_status = compatibility_store.CompatibilityResult(
packages=packages,
python_major_version='3',
status=status,
details=None,
dependency_info=None,
timestamp=None)
row_self = ('package1', 'SUCCESS', '3', None, None)
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
self_sql = 'REPLACE INTO self_compatibility_status values ' \
'(%s, %s, %s, %s, %s)'
with patch_pymysql:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses([comp_status])
mock_cursor.executemany.assert_called_with(self_sql, [row_self])
def test_get_pair_compatibility(self):
mock_client = mock.Mock()
def MockClient(project=None):
return mock_client
row = mock.Mock(status='SUCCESS',
py_version='3',
timestamp='2018-07-17 02:14:27.15768 UTC',
details=None)
mock_client.query.return_value = [row]
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
patch_bigquery = mock.patch(
'compatibility_lib.compatibility_store.bigquery', MockBigquery)
packages = [PACKAGE_1, PACKAGE_2]
with patch_bigquery:
res = store.get_pair_compatibility(packages)
self.assertEqual(len(res), 1)
self.assertEqual(len(res[0].packages), 2)
self.assertTrue(
isinstance(res[0], compatibility_store.CompatibilityResult))
def test_compatibility_combinations(self):
row1 = ('package1', 'package2', 'SUCCESS', '3',
'2018-07-17 02:14:27.15768 UTC', None)
row2 = ('package1', 'package3', 'SUCCESS', '3',
'2018-07-17 02:14:27.15768 UTC', None)
row3 = ('package2', 'package3', 'SUCCESS', '3',
'2018-07-17 02:14:27.15768 UTC', None)
store = compatibility_store.CompatibilityStore()
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
mock_cursor.fetchall.return_value = [row1, row2, row3]
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
packages = [PACKAGE_1, PACKAGE_2, PACKAGE_3]
with patch_pymysql:
res = store.get_compatibility_combinations(packages)
expected_pair_1 = frozenset({PACKAGE_1, PACKAGE_2})
expected_pair_2 = frozenset({PACKAGE_1, PACKAGE_3})
expected_pair_3 = frozenset({PACKAGE_2, PACKAGE_3})
self.assertEqual(len(res.keys()), 3)
self.assertEqual(
frozenset(res.keys()),
frozenset({expected_pair_1, expected_pair_2, expected_pair_3}))
def test_get_self_compatibilities(self):
mock_client = mock.Mock()
def MockClient(project=None):
return mock_client
packages = [PACKAGE_1, PACKAGE_2, PACKAGE_3, PACKAGE_4]
rows = []
for pkg in packages:
row = mock.Mock(install_name=pkg.install_name,
status='SUCCESS',
py_version='3',
timestamp='2018-07-17 01:07:08.936648 UTC',
details=None)
rows.append(row)
mock_client.query.return_value = rows
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
patch_bigquery = mock.patch(
'compatibility_lib.compatibility_store.bigquery', MockBigquery)
with patch_bigquery:
res = store.get_self_compatibilities(packages)
self.assertEqual(len(res), 4)
self.assertEqual(frozenset(res.keys()), frozenset(packages))
def test_get_self_compatibility(self):
mock_client = mock.Mock()
def MockClient(project=None):
return mock_client
row = mock.Mock(install_name=PACKAGE_1.install_name,
status='SUCCESS',
py_version='3',
timestamp='2018-07-17 01:07:08.936648 UTC',
details=None)
mock_client.query.return_value = [row]
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
patch_bigquery = mock.patch(
'compatibility_lib.compatibility_store.bigquery', MockBigquery)
with patch_bigquery:
res = store.get_self_compatibility(PACKAGE_1)
self.assertEqual(len(res), 1)
self.assertTrue(
isinstance(res[0], compatibility_store.CompatibilityResult))
def main():
parser = argparse.ArgumentParser(
description='Display a grid show the dependency compatibility ' +
'between Python packages')
parser.add_argument('--packages',
nargs='+',
default=_DEFAULT_INSTALL_NAMES,
help='the packages to display compatibility ' +
'information for')
parser.add_argument('--browser',
action='store_true',
default=False,
help='display the grid in a browser tab')
args = parser.parse_args()
store = compatibility_store.CompatibilityStore()
grid_builder = GridBuilder(store)
grid_html = grid_builder.build_grid(
(package.Package(install_name) for install_name in args.packages))
if args.browser:
_, grid_path = tempfile.mkstemp(suffix='.html')
with open(grid_path, 'wt') as f:
f.write(grid_html)
webbrowser.open_new_tab('file://' + grid_path)
else:
print(grid_html, end='')
def test_constructor(self):
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
expected__self_table_id = 'compatibility_checker.self_compatibility_status'
expected__pairwise_table_id = 'compatibility_checker.pairwise_compatibility_status'
expected__release_time_table_id = 'compatibility_checker.release_time_for_dependencies'
with patch_client:
store = compatibility_store.CompatibilityStore()
self.assertEqual(store._self_table_id, expected__self_table_id)
self.assertEqual(store._pairwise_table_id, expected__pairwise_table_id)
self.assertEqual(store._release_time_table_id,
expected__release_time_table_id)
self.assertEqual(
store._self_table,
compatibility_store._SELF_COMPATIBILITY_STATUS_TABLE_NAME)
self.assertEqual(
store._pairwise_table,
compatibility_store._PAIRWISE_COMPATIBILITY_STATUS_TABLE_NAME)
self.assertEqual(
store._release_time_table,
compatibility_store._RELEASE_TIME_FOR_DEPENDENCIES_TABLE_NAME)
def test_save_compatibility_statuses_self(self):
mock_client = mock.Mock()
packages = [PACKAGE_1]
timestamp = '2018-07-17 03:01:06.11693 UTC'
status = compatibility_store.Status.SUCCESS
comp_status = mock.Mock(packages=packages,
python_major_version='3',
status=status,
details=None,
dependency_info=None,
timestamp=timestamp)
row_self = {
'install_name': 'package1',
'status': 'SUCCESS',
'py_version': '3',
'timestamp': timestamp,
'details': None,
}
def MockClient(project=None):
return mock_client
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses([comp_status])
mock_client.insert_rows.assert_called_with(store._self_table,
[row_self])
def test_save_compatibility_statuses_release_time_for_latest(self):
mock_client = mock.Mock()
packages = [PACKAGE_4]
timestamp = '2018-07-17 03:01:06.11693 UTC'
status = compatibility_store.Status.SUCCESS
comp_status_py2 = mock.Mock(
packages=packages,
python_major_version='2',
status=status,
details=None,
dependency_info={'package4': {
'installed_version': '2.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}},
timestamp=timestamp)
comp_status_py3 = mock.Mock(
packages=packages,
python_major_version='3',
status=status,
details=None,
dependency_info={'package4': {
'installed_version': '2.2.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}},
timestamp=timestamp)
row_release_time = {
'install_name': 'package4[gcp]',
'dep_name': 'package4',
'installed_version': '2.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'timestamp': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
def MockClient(project=None):
return mock_client
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses(
[comp_status_py2, comp_status_py3])
mock_client.insert_rows.assert_called_with(
store._release_time_table, [row_release_time])
def test_save_compatibility_statuses_release_time_for_latest(self):
packages = [PACKAGE_4]
timestamp = '2018-07-17 03:01:06.11693 UTC'
status = compatibility_store.Status.SUCCESS
comp_status_py2 = compatibility_store.CompatibilityResult(
packages=packages,
python_major_version='2',
status=status,
details=None,
dependency_info={
'package4': {
'installed_version': '12.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '12.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
},
timestamp=timestamp)
comp_status_py3 = compatibility_store.CompatibilityResult(
packages=packages,
python_major_version='3',
status=status,
details=None,
dependency_info={
'package4': {
'installed_version': '2.2.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}
},
timestamp=timestamp)
row_release_time = ('package4[gcp]', 'package4', '12.7.0',
'2018-05-12T16:26:31', '12.7.0',
'2018-05-12T16:26:31', True,
'2018-07-13T17:11:29.140608')
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
sql = 'REPLACE INTO release_time_for_dependencies values ' \
'(%s, %s, %s, %s, %s, %s, %s, %s)'
with patch_pymysql:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses(
[comp_status_py2, comp_status_py3])
mock_cursor.executemany.assert_called_with(sql, [row_release_time])
def main():
parser = argparse.ArgumentParser(
description='Display a grid show the dependency compatibility ' +
'between Python packages')
parser.add_argument('--packages',
nargs='+',
default=_DEFAULT_INSTALL_NAMES,
help='the packages to display compatibility ' +
'information for')
parser.add_argument('--browser',
action='store_true',
default=False,
help='display the grid in a browser tab')
args = parser.parse_args()
checker = compatibility_checker.CompatibilityChecker()
store = compatibility_store.CompatibilityStore()
packages = [
package.Package(install_name) for install_name in args.packages
]
logging.info("Getting self compatibility results...")
package_to_results = store.get_self_compatibilities(packages)
logging.info("Getting pairwise compatibility results...")
pairwise_to_results = store.get_compatibility_combinations(packages)
package_with_dependency_info = {}
for pkg in configs.PKG_LIST:
dep_info = store.get_dependency_info(pkg)
package_with_dependency_info[pkg] = dep_info
results = _ResultHolder(package_to_results, pairwise_to_results,
package_with_dependency_info, checker, store)
dashboard_builder = DashboardBuilder(packages, results)
# Build the pairwise grid dashboard
logging.info('Starting build the grid...')
grid_html = dashboard_builder.build_dashboard(
'dashboard/grid-template.html')
grid_path = os.path.dirname(os.path.abspath(__file__)) + '/grid.html'
with open(grid_path, 'wt') as f:
f.write(grid_html)
# Build the dashboard main page
logging.info('Starting build the main dashboard...')
main_html = dashboard_builder.build_dashboard(
'dashboard/main-template.html')
main_path = os.path.dirname(os.path.abspath(__file__)) + '/index.html'
with open(main_path, 'wt') as f:
f.write(main_html)
if args.browser:
webbrowser.open_new_tab('file://' + main_path)
def test_compatibility_combinations(self):
mock_client = mock.Mock()
def MockClient(project=None):
return mock_client
row1 = mock.Mock(
install_name_lower='package1',
install_name_higher='package2',
status='SUCCESS',
py_version='3',
timestamp='2018-07-17 02:14:27.15768 UTC',
details=None)
row2 = mock.Mock(
install_name_lower='package1',
install_name_higher='package3',
status='SUCCESS',
py_version='3',
timestamp='2018-07-17 02:14:27.15768 UTC',
details=None)
row3 = mock.Mock(
install_name_lower='package2',
install_name_higher='package3',
status='SUCCESS',
py_version='3',
timestamp='2018-07-17 02:14:27.15768 UTC',
details=None)
mock_client.query.return_value = [row1, row2, row3]
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
patch_bigquery = mock.patch(
'compatibility_lib.compatibility_store.bigquery', MockBigquery)
packages = [PACKAGE_1, PACKAGE_2, PACKAGE_3]
with patch_bigquery:
res = store.get_compatibility_combinations(packages)
expected_pair_1 = frozenset({PACKAGE_1, PACKAGE_2})
expected_pair_2 = frozenset({PACKAGE_1, PACKAGE_3})
expected_pair_3 = frozenset({PACKAGE_2, PACKAGE_3})
self.assertEqual(len(res.keys()), 3)
self.assertEqual(
frozenset(res.keys()),
frozenset({expected_pair_1, expected_pair_2, expected_pair_3}))
def test_get_pair_compatibility_value_error(self):
# get_pair_compatibility needs 2 packages to run the check, or it will
# raise ValueError.
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
store = compatibility_store.CompatibilityStore()
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
packages = [PACKAGE_1]
with patch_pymysql, self.assertRaises(ValueError):
store.get_pair_compatibility(packages)
def test_get_pair_compatibility_value_error(self):
# get_pair_compatibility needs 2 packages to run the check, or it will
# raise ValueError.
mock_client = mock.Mock()
def MockClient(project=None):
return mock_client
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
packages = [PACKAGE_1]
with self.assertRaises(ValueError):
store.get_pair_compatibility(packages)
def test_get_self_compatibility(self):
row = (PACKAGE_1.install_name, 'SUCCESS', '3',
'2018-07-17 01:07:08.936648 UTC', None)
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
mock_cursor.fetchall.return_value = [row]
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
store = compatibility_store.CompatibilityStore()
with patch_pymysql:
res = store.get_self_compatibility(PACKAGE_1)
self.assertEqual(len(res), 1)
self.assertTrue(
isinstance(res[0], compatibility_store.CompatibilityResult))
def test_get_pair_compatibility(self):
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
row = ('pkg1', 'pkg2', 'SUCCESS', '3', '2018-07-17 02:14:27.15768 UTC',
None)
mock_cursor.fetchall.return_value = [row]
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
store = compatibility_store.CompatibilityStore()
packages = [PACKAGE_1, PACKAGE_2]
with patch_pymysql:
res = store.get_pair_compatibility(packages)
self.assertEqual(len(res), 1)
self.assertEqual(len(res[0].packages), 2)
self.assertTrue(
isinstance(res[0], compatibility_store.CompatibilityResult))
def test_get_packages(self):
pkgs = ['google-api-core', 'apache-beam']
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
mock_cursor.fetchall.return_value = [[pkgs[0], 'SUCCESS'],
[pkgs[1], 'CHECK WARNING']]
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
with patch_pymysql:
store = compatibility_store.CompatibilityStore()
packages = list(store.get_packages())
self.assertEqual(len(packages), 2)
for i, pkg in enumerate(packages):
self.assertTrue(
isinstance(pkg, compatibility_store.package.Package))
self.assertEqual(pkg.install_name, pkgs[i])
def test_get_self_compatibilities(self):
packages = [PACKAGE_1, PACKAGE_2, PACKAGE_3, PACKAGE_4]
rows = []
for pkg in packages:
row = (pkg.install_name, 'SUCCESS', '3',
'2018-07-17 01:07:08.936648 UTC', None)
rows.append(row)
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
mock_cursor.fetchall.return_value = rows
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
store = compatibility_store.CompatibilityStore()
with patch_pymysql:
res = store.get_self_compatibilities(packages)
self.assertEqual(len(res), 4)
self.assertEqual(frozenset(res.keys()), frozenset(packages))
def test_get_packages(self):
mock_client = mock.Mock()
pkgs = ['google-api-core', 'apache-beam']
mock_client.query.return_value = [
[pkgs[0], 'SUCCESS'],
[pkgs[1], 'CHECK WARNING'],
]
def MockClient(project=None):
return mock_client
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
packages = list(store.get_packages())
self.assertEqual(len(packages), 2)
for i, pkg in enumerate(packages):
self.assertTrue(
isinstance(pkg, compatibility_store.package.Package))
self.assertEqual(pkg.install_name, pkgs[i])
def main():
parser = argparse.ArgumentParser(
description='Display a grid show the dependency compatibility ' +
'between Python packages')
parser.add_argument('--packages',
nargs='+',
default=_DEFAULT_INSTALL_NAMES,
help='the packages to display compatibility ' +
'information for')
parser.add_argument('--browser',
action='store_true',
default=False,
help='display the grid in a browser tab')
args = parser.parse_args()
checker = compatibility_checker.CompatibilityChecker()
store = compatibility_store.CompatibilityStore()
instance_flag = '-instances={}=tcp:{}'.format(INSTANCE_CONNECTION_NAME,
PORT)
cloud_sql_proxy_path = './cloud_sql_proxy'
try:
# Run cloud_sql_proxy
process = popen_spawn.PopenSpawn([cloud_sql_proxy_path, instance_flag])
process.expect('Ready for new connection', timeout=5)
packages = [
package.Package(install_name) for install_name in args.packages
]
logging.info('Getting self compatibility results...')
package_to_results = store.get_self_compatibilities(packages)
logging.info('Getting pairwise compatibility results...')
pairwise_to_results = store.get_compatibility_combinations(packages)
package_with_dependency_info = {}
for pkg in configs.PKG_LIST:
dep_info = store.get_dependency_info(pkg)
package_with_dependency_info[pkg] = dep_info
results = _ResultHolder(package_to_results, pairwise_to_results,
package_with_dependency_info, checker, store)
dashboard_builder = DashboardBuilder(packages, results)
# Build the pairwise grid dashboard
logging.info('Starting build the grid...')
grid_html = dashboard_builder.build_dashboard(
'dashboard/grid-template.html')
grid_path = os.path.dirname(os.path.abspath(__file__)) + '/grid.html'
with open(grid_path, 'wt') as f:
f.write(grid_html)
# Build the dashboard main page
logging.info('Starting build the main dashboard...')
main_html = dashboard_builder.build_dashboard(
'dashboard/main-template.html')
main_path = os.path.dirname(os.path.abspath(__file__)) + '/index.html'
with open(main_path, 'wt') as f:
f.write(main_html)
except Exception:
raise DashboardBuilderError('Error occurs when building dashboard.'
'Output: {}'.format(process.before))
finally:
process.kill(signal.SIGTERM)
if args.browser:
webbrowser.open_new_tab('file://' + main_path)
import argparse
import contextlib
import datetime
import itertools
import signal
import pexpect
from pexpect import popen_spawn
from compatibility_lib import compatibility_checker
from compatibility_lib import compatibility_store
from compatibility_lib import configs
from compatibility_lib import package
checker = compatibility_checker.CompatibilityChecker(max_workers=800)
store = compatibility_store.CompatibilityStore()
PY2 = '2'
PY3 = '3'
INSTANCE_CONNECTION_NAME = 'python-compatibility-tools:us-central1:' \
'compatibility-data'
PORT = '3306'
class ConnectionError(Exception):
pass
def _result_dict_to_compatibility_result(results):
import pybadges
from compatibility_lib import compatibility_checker
from compatibility_lib import compatibility_store
from compatibility_lib import configs
from compatibility_lib import dependency_highlighter
from compatibility_lib import deprecated_dep_finder
# Initializations
DB_CONNECTION_NAME = 'python-compatibility-tools:us-central1:' \
'compatibility-data'
UNIX_SOCKET = '/cloudsql/{}'.format(DB_CONNECTION_NAME)
checker = compatibility_checker.CompatibilityChecker()
store = compatibility_store.CompatibilityStore(mysql_unix_socket=UNIX_SOCKET)
highlighter = dependency_highlighter.DependencyHighlighter(
checker=checker, store=store)
finder = deprecated_dep_finder.DeprecatedDepFinder(
checker=checker, store=store)
priority_level = dependency_highlighter.PriorityLevel
TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S"
URL_PREFIX = 'https://img.shields.io/badge/'
GITHUB_HEAD_NAME = 'github head'
GITHUB_API = 'https://api.github.com/repos'
GITHUB_CACHE_TIME = 1800 # seconds
SVG_CONTENT_TYPE = 'image/svg+xml'
EMPTY_DETAILS = 'NO DETAILS'
PACKAGE_NOT_SUPPORTED = "The package is not supported by checker server."
def __init__(self, py_version='3'):
self.py_version = py_version
self._store = compatibility_store.CompatibilityStore()
self._checker = compatibility_checker.CompatibilityChecker()
def test_save_compatibility_statuses_release_time_for_latest_many_packages(
self):
mock_client = mock.Mock()
timestamp = '2018-07-17 03:01:06.11693 UTC'
status = compatibility_store.Status.SUCCESS
apache_beam_py2 = mock.Mock(
packages=[package.Package('apache-beam[gcp]')],
python_major_version='2',
status=status,
details=None,
dependency_info={
'six': {
'installed_version': '9.9.9',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
},
'apache-beam': {
'installed_version': '2.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
},
timestamp=timestamp)
apache_beam_py3 = mock.Mock(
packages=[package.Package('apache-beam[gcp]')],
python_major_version='3',
status=status,
details=None,
dependency_info={
'apache-beam': {
'installed_version': '2.2.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}
},
timestamp=timestamp)
google_api_core_py2 = mock.Mock(
packages=[package.Package('google-api-core')],
python_major_version='2',
status=status,
details=None,
dependency_info={
'google-api-core': {
'installed_version': '3.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
},
timestamp=timestamp)
google_api_core_py3 = mock.Mock(
packages=[package.Package('google-api-core')],
python_major_version='3',
status=status,
details=None,
dependency_info={
'google-api-core': {
'installed_version': '3.7.1',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}
},
timestamp=timestamp)
apache_beam_row = {
'install_name': 'apache-beam[gcp]',
'dep_name': 'apache-beam',
'installed_version': '2.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
'timestamp': '2018-07-13T17:11:29.140608',
}
six_row = {
'install_name': 'apache-beam[gcp]',
'dep_name': 'six',
'installed_version': '9.9.9',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
'timestamp': '2018-07-13T17:11:29.140608',
}
google_api_core_row = {
'install_name': 'google-api-core',
'dep_name': 'google-api-core',
'installed_version': '3.7.1',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
'timestamp': '2018-07-13T17:11:29.140608',
}
def MockClient(project=None):
return mock_client
patch_client = mock.patch(
'compatibility_lib.compatibility_store.bigquery.Client',
MockClient)
with patch_client:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses([
apache_beam_py2, apache_beam_py3, google_api_core_py2,
google_api_core_py3
])
mock_client.insert_rows.assert_called_with(
store._release_time_table,
[apache_beam_row, six_row, google_api_core_row])
def test_save_compatibility_statuses_release_time_for_latest_many_packages(
self):
status = compatibility_store.Status.SUCCESS
apache_beam_py2 = compatibility_store.CompatibilityResult(
packages=[package.Package('apache-beam[gcp]')],
python_major_version='2',
status=status,
details=None,
dependency_info={
'six': {
'installed_version': '9.9.9',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
},
'apache-beam': {
'installed_version': '2.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
},
timestamp=None)
apache_beam_py3 = compatibility_store.CompatibilityResult(
packages=[package.Package('apache-beam[gcp]')],
python_major_version='3',
status=status,
details=None,
dependency_info={
'apache-beam': {
'installed_version': '2.2.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}
},
timestamp=None)
google_api_core_py2 = compatibility_store.CompatibilityResult(
packages=[package.Package('google-api-core')],
python_major_version='2',
status=status,
details=None,
dependency_info={
'google-api-core': {
'installed_version': '3.7.0',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': True,
}
},
timestamp=None)
google_api_core_py3 = compatibility_store.CompatibilityResult(
packages=[package.Package('google-api-core')],
python_major_version='3',
status=status,
details=None,
dependency_info={
'google-api-core': {
'installed_version': '3.7.1',
'installed_version_time': '2018-05-12T16:26:31',
'latest_version': '2.7.0',
'current_time': '2018-07-13T17:11:29.140608',
'latest_version_time': '2018-05-12T16:26:31',
'is_latest': False,
}
},
timestamp=None)
apache_beam_row = ('apache-beam[gcp]', 'apache-beam', '2.7.0',
'2018-05-12T16:26:31', '2.7.0',
'2018-05-12T16:26:31', True,
'2018-07-13T17:11:29.140608')
six_row = ('apache-beam[gcp]', 'six', '9.9.9', '2018-05-12T16:26:31',
'2.7.0', '2018-05-12T16:26:31', False,
'2018-07-13T17:11:29.140608')
google_api_core_row = ('google-api-core', 'google-api-core', '3.7.1',
'2018-05-12T16:26:31', '2.7.0',
'2018-05-12T16:26:31', False,
'2018-07-13T17:11:29.140608')
mock_pymysql = mock.Mock()
mock_conn = mock.Mock()
mock_cursor = mock.Mock()
mock_pymysql.connect.return_value = mock_conn
mock_conn.cursor.return_value = mock_cursor
patch_pymysql = mock.patch(
'compatibility_lib.compatibility_store.pymysql', mock_pymysql)
sql = 'REPLACE INTO release_time_for_dependencies values ' \
'(%s, %s, %s, %s, %s, %s, %s, %s)'
with patch_pymysql:
store = compatibility_store.CompatibilityStore()
store.save_compatibility_statuses([
apache_beam_py2, apache_beam_py3, google_api_core_py2,
google_api_core_py3
])
mock_cursor.executemany.assert_called_with(
sql, [apache_beam_row, six_row, google_api_core_row])
