def test_commit_by_timestamp(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(
[self.stash_repository.commit(ref='1abe25b443e9')],
self.database.find_commits_by_timestamp(repository_id='safari',
branch='main',
timestamp=1601663000),
)
self.assertEqual(
[self.svn_repository.commit(ref=6)],
self.database.find_commits_by_timestamp(repository_id='webkit',
branch='main',
timestamp=1601639900),
)
self.assertEqual(
2,
len(
self.database.find_commits_by_timestamp(
repository_id='safari',
branch='main',
timestamp=1601668000)))
def test_invalid_upload(self, client, **kwargs):
with MockModelFactory.safari(), MockModelFactory.webkit():
upload_content = 'bad data'.encode('ascii')
upload_meta = dict(
configuration=json.dumps(
ConfigurationContextTest.CONFIGURATIONS[0],
cls=Configuration.Encoder),
suite='layout-tests',
commits=json.dumps([
dict(repository_id='safari',
id='d8bce26fa65c6fc8f39c17927abb77f69fab82fc'),
dict(repository_id='webkit', id='6')
]),
)
response = self.upload_file(
client, f'{self.URL}/{self.ARCHIVE_API_ENDPOINT}', upload_meta,
upload_content)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json()['description'],
'Archive is not a zipfile')
response = client.post(f'{self.URL}/{self.ARCHIVE_API_ENDPOINT}',
data=str(json.dumps(upload_meta)))
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json()['description'],
'No archive provided')
def test_result_retrieval_by_sdk(self,
redis=StrictRedis,
cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
self.assertEqual(
0,
len(
self.model.upload_context.find_test_results(
configurations=[
Configuration(platform='iOS', sdk='15A432')
],
suite='layout-tests',
recent=True)))
results = self.model.upload_context.find_test_results(
configurations=[Configuration(platform='iOS', sdk='15A432')],
suite='layout-tests',
recent=False)
self.assertEqual(6, len(results))
for config, values in results.items():
self.assertEqual(config.version, 11000000)
for value in values:
self.assertEqual(value['sdk'], '15A432')
self.assertEqual(value['test_results'],
MockModelFactory.layout_test_results())
def test_callback(self, redis=StrictRedis, cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
configuration_to_search = Configuration(platform='iOS',
version='12.0.0',
is_simulator=True,
style='Asan')
configuration, uploads = next(
iter(
self.model.upload_context.find_test_results(
configurations=[configuration_to_search],
suite='layout-tests',
recent=False).items()))
self.model.upload_context.process_test_results(
configuration=configuration,
commits=uploads[0]['commits'],
suite='layout-tests',
test_results=uploads[0]['test_results'],
timestamp=uploads[0]['timestamp'],
)
# Using suite results as a proxy to tell if callbacks were triggered
self.assertEqual(
1,
len(
self.model.suite_context.find_by_commit(
configurations=[Configuration()], suite='layout-tests')))
def setup_webserver(cls, app, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
cassandra.drop_keyspace(keyspace=cls.KEYSPACE)
model = MockModelFactory.create(redis=redis(), cassandra=cassandra(keyspace=cls.KEYSPACE, create_keyspace=True))
model.upload_context.register_upload_callback('python-tests', lambda **kwargs: dict(status='ok'))
MockModelFactory.add_mock_results(model)
app.register_blueprint(APIRoutes(model))
def test_process_commit(self, client, **kwargs):
with MockModelFactory.safari(), MockModelFactory.webkit():
response = client.post(self.URL + '/api/upload/process?platform=Mac&style=Release&flavor=wk2&id=d8bce26fa65c')
self.assertEqual(response.status_code, 200)
self.assertEqual(1, len(response.json()))
self.assertEqual(['d8bce26fa65c6fc8f39c17927abb77f69fab82fc'], [result['commits'][1]['hash'] for result in response.json()])
self.assertEqual([dict(status='ok')], [element['processing']['python-tests'] for element in response.json()])
def test_sibling_commits(self,
redis=StrictRedis,
cassandra=CassandraContext):
self.maxDiff = None
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(
self.database.sibling_commits(
self.svn_repository.commit(ref=6), ['safari']),
{
'safari': [
self.stash_repository.commit(ref='d8bce26fa65c'),
self.stash_repository.commit(ref='bae5d1e90999'),
self.stash_repository.commit(ref='1abe25b443e9'),
self.stash_repository.commit(ref='fff83bb2d917'),
self.stash_repository.commit(ref='9b8311f25a77'),
]
},
)
self.assertEqual(
self.database.sibling_commits(
self.stash_repository.commit(ref='d8bce26fa65c'),
['webkit']),
{'webkit': [self.svn_repository.commit(ref=6)]},
)
self.assertEqual(
self.database.sibling_commits(
self.svn_repository.commit(ref=1), ['safari']),
{'safari': []},
)
def init_database(self, redis=StrictRedis, cassandra=CassandraContext):
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.model = MockModelFactory.create(redis=redis(),
cassandra=cassandra(
keyspace=self.KEYSPACE,
create_keyspace=True))
MockModelFactory.add_mock_results(
self.model,
test_results=dict(
details=dict(link='dummy-link'),
run_stats=dict(tests_skipped=0),
results={
'fast': {
'encoding': {
'css-cached-bom.html':
dict(expected='PASS', actual='FAIL', time=1.2),
'css-charset-default.xhtml':
dict(expected='FAIL', actual='FAIL', time=1.2),
'css-charset.html':
dict(expected='FAIL', actual='PASS', time=1.2),
'css-link-charset.html':
dict(expected='PASS', actual='PASS', time=1.2),
}
}
},
))
MockModelFactory.process_results(self.model)
def init_database(self, redis=StrictRedis, cassandra=CassandraContext):
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.model = MockModelFactory.create(redis=redis(),
cassandra=cassandra(
keyspace=self.KEYSPACE,
create_keyspace=True))
MockModelFactory.add_mock_results(self.model)
MockModelFactory.process_results(self.model)
def test_uuid_for_commits(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
uuid = CommitContext.uuid_for_commits([
self.stash_repository.commit(ref='bae5d1e90999'),
self.svn_repository.commit(ref=6),
])
self.assertEqual(uuid, 160166800000)
def test_no_failures(self, redis=StrictRedis, cassandra=CassandraContext):
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.model = MockModelFactory.create(redis=redis(), cassandra=cassandra(keyspace=self.KEYSPACE, create_keyspace=True))
MockModelFactory.add_mock_results(self.model)
MockModelFactory.process_results(self.model)
results = self.model.failure_context.failures_by_commit(
configurations=[Configuration(platform='Mac', style='Release', flavor='wk1')],
suite='layout-tests', recent=True, collapsed=False, unexpected=False,
)
self.assertEqual(len(results), 0)
def test_result_retrieval_branch(self, redis=StrictRedis, cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
results = self.model.upload_context.find_test_results(configurations=[Configuration(platform='iOS', is_simulator=True)], suite='layout-tests', branch='safari-606-branch', recent=True)
self.assertEqual(3, len(results))
for config, values in results.items():
self.assertEqual(config, Configuration(platform='iOS', is_simulator=True))
self.assertEqual(2, len(values))
for value in values:
self.assertEqual(value['test_results'], MockModelFactory.layout_test_results())
def test_process(self, client, **kwargs):
with MockModelFactory.safari(), MockModelFactory.webkit():
response = client.post(
self.URL +
'/api/upload/process?platform=Mac&style=Release&flavor=wk2')
self.assertEqual(response.status_code, 200)
self.assertEqual(5, len(response.json()))
self.assertEqual([dict(status='ok')] * 5, [
element['processing']['python-tests']
for element in response.json()
])
def init_database(self,
redis=StrictRedis,
cassandra=CassandraContext,
async_processing=False):
with MockModelFactory.safari(), MockModelFactory.webkit():
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.model = MockModelFactory.create(
redis=redis(),
cassandra=cassandra(keyspace=self.KEYSPACE,
create_keyspace=True),
async_processing=async_processing,
)
def test_commit_url(self, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.assertEqual(
'https://bitbucket.example.com/projects/SAFARI/repos/safari/commits/d8bce26fa65c6fc8f39c17927abb77f69fab82fc',
self.database.url(
self.stash_repository.commit(ref='d8bce26fa65c')),
)
self.assertEqual(
'https://commits.webkit.org/4@main',
self.database.url(self.svn_repository.commit(ref=6)),
)
def test_result_retrieval_limit(self,
redis=StrictRedis,
cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
results = self.model.upload_context.find_test_results(
configurations=[Configuration(platform='Mac')],
suite='layout-tests',
limit=2,
recent=True)
self.assertEqual(sum([len(value) for value in results.values()]), 12)
def test_commit_from_svn_repo(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.database.register_partial_commit('webkit', revision=6)
self.assertEqual(
[self.svn_repository.commit_for_id(id=6)],
self.database.find_commits_by_id(repository_id='webkit',
branch='trunk',
commit_id=6),
)
def add_all_commits_to_database(self):
with MockModelFactory.safari() as safari, MockModelFactory.webkit(
) as webkit:
with self.database, self.database.cassandra.batch_query_context():
for key, repository in dict(safari=safari,
webkit=webkit).items():
for branch, commits in repository.commits.items():
for commit in commits:
self.database.register_partial_commit(
key,
ref=commit.hash or commit.revision,
)
def setup_webserver(cls,
app,
redis=StrictRedis,
cassandra=CassandraContext):
cassandra.drop_keyspace(keyspace=cls.KEYSPACE)
model = MockModelFactory.create(redis=redis(),
cassandra=cassandra(
keyspace=cls.KEYSPACE,
create_keyspace=True))
app.register_blueprint(APIRoutes(model))
MockModelFactory.add_mock_results(model)
MockModelFactory.process_results(model)
def test_commit_from_stash_repo(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.database.register_partial_commit('safari',
hash='d8bce26fa65c',
fast=False)
self.assertEqual(
[self.stash_repository.commit(ref='d8bce26fa65c')],
self.database.find_commits_by_ref(repository_id='safari',
ref='d8bce26fa65c'),
)
def register_all_commits(self, client):
with MockModelFactory.safari() as safari, MockModelFactory.webkit(
) as webkit:
for name, mock_repository in dict(safari=safari,
webkit=webkit).items():
for commit_list in mock_repository.commits.values():
for commit in commit_list:
self.assertEqual(
200,
client.post(self.URL + '/api/commits/register',
data=dict(
id=commit.hash or commit.revision,
repository_id=name)).status_code)
def test_next_commit(self, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(
self.database.next_commit(self.svn_repository.commit(ref=4)),
self.svn_repository.commit(ref=6),
)
self.assertEqual(
self.database.next_commit(
self.stash_repository.commit(ref='bae5d1e90999')),
self.stash_repository.commit(ref='d8bce26fa65c'),
)
def test_sdk_differentiation(self, redis=StrictRedis, cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
configuration_to_search = Configuration(platform='iOS', version='12.0.0', is_simulator=True, style='Asan')
results = self.model.upload_context.find_test_results(configurations=[configuration_to_search], suite='layout-tests', recent=False)
self.assertEqual(1, len(results))
MockModelFactory.add_mock_results(self.model, configuration=Configuration(
platform='iOS', version='12.0.0', sdk='16A405', is_simulator=True, architecture='x86_64', style='Asan',
))
results = self.model.upload_context.find_test_results(configurations=[configuration_to_search], suite='layout-tests', recent=False)
self.assertEqual(2, len(results))
results = self.model.upload_context.find_test_results(configurations=[Configuration(platform='iOS', sdk='16A405')], suite='layout-tests', recent=False)
self.assertEqual(1, len(results))
def test_ref_svn(self):
with MockModelFactory.webkit():
svn_repo = WebKitRepository()
commit = svn_repo.commit(ref=7)
self.assertEqual(commit.uuid, 160164090000)
self.assertEqual(commit.message, '7th commit')
self.assertEqual(commit.branch, 'branch-a')
def test_ref_stash(self):
with MockModelFactory.safari() as safari:
git_repo = StashRepository('https://{}'.format(safari.remote))
self.assertEqual('safari', git_repo.key)
commit = git_repo.commit(ref='1abe25b443e9')
self.assertEqual(commit.uuid, 160166300000)
self.assertEqual(commit.branch, 'main')
def test_branches(self, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(['branch-a', 'branch-b', 'main'],
self.database.branches(repository_id='safari'))
self.assertEqual(
['branch-a', 'branch-b', 'main'],
self.database.branches(repository_id='webkit'),
)
self.assertEqual(['branch-a', 'branch-b'],
self.database.branches(repository_id='safari',
branch='branch'))
self.assertEqual(['branch-a'],
self.database.branches(repository_id='webkit',
branch='branch-a'))
def test_svn_commits_in_range(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(
[
self.svn_repository.commit(ref=6),
self.svn_repository.commit(ref=4)
],
self.database.find_commits_in_range(repository_id='webkit',
branch='main',
begin=1601637900,
end=1601639900),
)
def test_upload(self, client, **kwargs):
upload_dict = dict(
suite='layout-tests',
commits=[
MockStashRepository.safari().commit_for_id('bb6bda5f'),
MockSVNRepository.webkit().commit_for_id(236542)
],
configuration=Configuration.Encoder().default(
Configuration(
platform='Mac',
version='10.14.0',
sdk='18A391',
is_simulator=False,
architecture='x86_64',
style='Release',
flavor='wk2',
)),
test_results=MockModelFactory.layout_test_results(),
timestamp=int(time.time()),
)
response = client.post(self.URL + '/api/upload',
data=str(
json.dumps(upload_dict,
cls=Commit.Encoder)))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'ok')
self.assertEqual(response.json()['processing']['python-tests'],
dict(status='ok'))
response = client.get(self.URL + '/api/upload')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0],
Commit.Encoder().default(upload_dict))
def test_upload_partial(self, client, **kwargs):
upload_dict = dict(
suite='layout-tests',
commits=[
dict(repository_id='safari',
id='d8bce26fa65c6fc8f39c17927abb77f69fab82fc'),
dict(repository_id='webkit', id='6')
],
configuration=Configuration.Encoder().default(
Configuration(
platform='iOS',
version='12.0.0',
sdk='16A404',
is_simulator=True,
architecture='x86_64',
style='Release',
flavor='wk2',
)),
test_results=MockModelFactory.layout_test_results(),
timestamp=int(time.time()),
)
response = client.post(self.URL + '/api/upload',
data=str(json.dumps(upload_dict)))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['status'], 'ok')
self.assertEqual(response.json()['processing']['python-tests'],
dict(status='ok'))
response = client.get(self.URL + '/api/upload')
self.assertEqual(response.status_code, 200)
for key in ['suite', 'configuration', 'test_results', 'timestamp']:
self.assertEqual(response.json()[0][key], upload_dict[key])
def test_stash_commits_in_range(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
self.assertEqual(
[
self.stash_repository.commit(ref='bae5d1e90999'),
self.stash_repository.commit(ref='1abe25b443e9')
],
self.database.find_commits_in_range(repository_id='safari',
branch='main',
begin=1601663000,
end=1601668000),
)
