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 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 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 init_database(self, redis=StrictRedis, cassandra=CassandraContext):
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))
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 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_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_callback(self, redis=StrictRedis, cassandra=CassandraContext):
self.init_database(redis=redis, cassandra=cassandra)
MockModelFactory.add_mock_results(self.model)
with MockModelFactory.safari(), MockModelFactory.webkit():
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 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 setup_webserver(cls, app, redis=StrictRedis, cassandra=CassandraContext):
with URLFactoryTest.mock(), MockModelFactory.safari(), MockModelFactory.webkit():
cassandra.drop_keyspace(keyspace=cls.KEYSPACE)
model = MockModelFactory.create(redis=redis(), cassandra=cassandra(keyspace=cls.KEYSPACE, create_keyspace=True))
model.ci_context.add_url_factory(BuildbotURLFactory(master='build.webkit.org', redis=model.redis))
app.register_blueprint(APIRoutes(model))
with model.upload_context:
# Mock results are more complicated because we want to attach results to builders
for configuration in [
Configuration(platform='Mac', version_name='Catalina', version='10.15.0', sdk='19A500', is_simulator=False, architecture='x86_64', style='Release', flavor='wk1'),
Configuration(platform='Mac', version_name='Catalina', version='10.15.0', sdk='19A500', is_simulator=False, architecture='x86_64', style='Release', flavor='wk2'),
Configuration(platform='Mac', version_name='Mojave', version='10.14.0', sdk='18A500', is_simulator=False, architecture='x86_64', style='Release', flavor='wk1'),
Configuration(platform='Mac', version_name='Mojave', version='10.14.0', sdk='18A500', is_simulator=False, architecture='x86_64', style='Release', flavor='wk2'),
]:
build_count = [1]
def callback(commits, model=model, configuration=configuration, count=build_count):
results = MockModelFactory.layout_test_results()
results['details'] = {
'buildbot-master': URLFactoryTest.BUILD_MASTER,
'builder-name': f'{configuration.version_name}-{configuration.style}-{configuration.flavor.upper()}-Tests',
'build-number': str(count[0]),
'buildbot-worker': {
'Mojave': 'bot1',
'Catalina': 'bot2',
}.get(configuration.version_name, None),
}
model.upload_context.upload_test_results(configuration, commits, suite='layout-tests', timestamp=time.time(), test_results=results)
count[0] += 1
MockModelFactory.iterate_all_commits(model, callback)
MockModelFactory.process_results(model, configuration)
def test_svn(self):
with MockModelFactory.webkit():
svn_repo = WebKitRepository()
self.assertTrue('webkit', svn_repo.key)
commit = svn_repo.commit(revision=6)
self.assertEqual(commit.uuid, 160163990000)
self.assertEqual(commit.message, '6th commit')
self.assertEqual(commit.branch, 'trunk')
def init_database(self, redis=StrictRedis, cassandra=CassandraContext):
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))
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_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 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 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 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_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 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 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))
app.register_blueprint(APIRoutes(model))
MockModelFactory.add_mock_results(model)
MockModelFactory.process_results(model)
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_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),
)
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_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 setup_webserver(cls, app, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
cassandra.drop_keyspace(keyspace=cls.KEYSPACE)
redis_instance = redis()
model = Model(
redis=redis_instance, cassandra=cassandra(keyspace=cls.KEYSPACE, create_keyspace=True),
repositories=[
WebKitRepository(),
StashRepository('https://bitbucket.example.com/projects/SAFARI/repos/safari'),
],
)
api_routes = APIRoutes(model=model, import_name=__name__)
view_routes = ViewRoutes(model=model, controller=api_routes, import_name=__name__)
app.register_blueprint(api_routes)
app.register_blueprint(view_routes)
def register_all_commits(self, client):
for name, repo in dict(safari=MockModelFactory.safari(),
webkit=MockModelFactory.webkit()).items():
for commits in repo.commits.values():
for commit in commits:
self.assertEqual(
200,
client.post(self.URL + '/api/commits/register',
data=dict(
repository_id=name,
id=commit.revision or commit.hash,
branch=commit.branch,
timestamp=commit.timestamp,
order=commit.order,
committer=commit.author.email,
message=commit.message,
)).status_code)
def test_stash_commits_between(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
commits = [
self.stash_repository.commit(ref='1abe25b443e9'),
self.stash_repository.commit(ref='fff83bb2d917'),
self.stash_repository.commit(ref='9b8311f25a77'),
]
self.assertEqual(
commits,
self.database.find_commits_in_range(repository_id='safari',
branch='main',
begin=commits[-1],
end=commits[0]))
def test_svn_commits_between(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
self.add_all_commits_to_database()
commits = [
self.svn_repository.commit(ref=6),
self.svn_repository.commit(ref=4),
self.svn_repository.commit(ref=2),
]
self.assertEqual(
commits,
self.database.find_commits_in_range(repository_id='webkit',
branch='main',
begin=commits[-1],
end=commits[0]))
def setup_webserver(cls,
app,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
redis_instance = redis()
safari = StashRepository(
'https://bitbucket.example.com/projects/SAFARI/repos/safari')
webkit = WebKitRepository()
cassandra.drop_keyspace(keyspace=cls.KEYSPACE)
cassandra_instance = cassandra(keyspace=cls.KEYSPACE,
create_keyspace=True)
app.register_blueprint(
APIRoutes(
Model(redis=redis_instance,
cassandra=cassandra_instance,
repositories=[safari, webkit])))
def test_no_failures(self, redis=StrictRedis, cassandra=CassandraContext):
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))
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)
