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_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):
redis_instance = redis()
self.stash_repository = StashRepository(
'https://bitbucket.example.com/projects/SAFARI/repos/safari')
self.svn_repository = WebKitRepository()
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.database = CommitContext(
redis=redis_instance,
cassandra=cassandra(keyspace=self.KEYSPACE, create_keyspace=True),
)
self.database.register_repository(self.stash_repository)
self.database.register_repository(self.svn_repository)
def create(cls, redis, cassandra, async_processing=False):
oldest_commit = time.time()
with cls.safari() as safari, cls.webkit() as webkit:
for repo in [safari, webkit]:
for commits in repo.commits.values():
for commit in commits:
oldest_commit = min(oldest_commit, commit.timestamp)
model = Model(
redis=redis,
cassandra=cassandra,
repositories=[
StashRepository(
'https://bitbucket.example.com/projects/SAFARI/repos/safari'
),
WebKitRepository(),
],
default_ttl_seconds=time.time() - oldest_commit + Model.TTL_WEEK,
archive_ttl_seconds=time.time() - oldest_commit + Model.TTL_WEEK,
async_processing=async_processing,
)
with cls.safari() as safari, cls.webkit() as webkit:
with model.commit_context, model.commit_context.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:
model.commit_context.register_partial_commit(
key,
hash=commit.hash,
revision=commit.revision,
fast=False,
)
return model
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 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 __init__(self, environment):
nodes = ['localhost']
cassandra_class = CassandraContext
if environment.cassandra_server == MOCK_CASSANDRA:
cassandra_class = MockCassandraContext
auth_provider = None
if environment.cassandra_username and environment.cassandra_password:
auth_provider = PlainTextAuthProvider(
environment.cassandra_username, environment.cassandra_password)
if environment.drop_keyspace:
cassandra_class.drop_keyspace(nodes=nodes,
keyspace=environment.keyspace,
auth_provider=auth_provider)
cassandra = cassandra_class(
nodes=nodes,
keyspace=environment.keyspace,
auth_provider=auth_provider,
create_keyspace=environment.create_keyspace,
replication_map=None,
)
if environment.redis_host == 'mock':
redis = FakeStrictRedis()
elif environment.redis_url:
redis = StrictRedis.from_url(environment.redis_url)
else:
redis = StrictRedis(
port=environment.redis_port,
host=environment.redis_host,
password=environment.redis_password,
)
redis.ping() # Force a connection with the redis database
webkit = WebKitRepository()
super(ModelFromEnvironment, self).__init__(
redis=redis,
cassandra=cassandra,
repositories=[webkit],
default_ttl_seconds=self.TTL_SECONDS,
async_processing=True,
)
class CommitContextTest(WaitForDockerTestCase):
KEYSPACE = 'commit_mapping_test_keyspace'
def init_database(self, redis=StrictRedis, cassandra=CassandraContext):
redis_instance = redis()
self.stash_repository = StashRepository(
'https://bitbucket.example.com/projects/SAFARI/repos/safari')
self.svn_repository = WebKitRepository()
cassandra.drop_keyspace(keyspace=self.KEYSPACE)
self.database = CommitContext(
redis=redis_instance,
cassandra=cassandra(keyspace=self.KEYSPACE, create_keyspace=True),
)
self.database.register_repository(self.stash_repository)
self.database.register_repository(self.svn_repository)
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,
hash=commit.hash,
revision=commit.revision,
fast=False,
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_verify_table(self, redis=StrictRedis, cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
CommitContext(redis=redis(),
cassandra=cassandra(keyspace=self.KEYSPACE))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_commit_by_id(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='d8bce26fa65c')],
self.database.find_commits_by_ref(repository_id='safari',
ref='d8bce26fa65c'),
)
self.assertEqual(
[self.svn_repository.commit(ref=6)],
self.database.find_commits_by_ref(repository_id='webkit',
ref=6),
)
self.assertEqual(
0,
len(
self.database.find_commits_by_ref(repository_id='webkit',
ref='1234')))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_commit_by_uuid(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_uuid(repository_id='safari',
branch='main',
uuid=160166300000),
)
self.assertEqual(
[self.svn_repository.commit(ref=6)],
self.database.find_commits_by_uuid(repository_id='webkit',
branch='main',
uuid=160163990000),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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)))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_all_commits_stash(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(
5,
len(
self.database.find_commits_in_range(repository_id='safari',
branch='main')))
self.assertEqual(
[
self.stash_repository.commit(ref='d8bce26fa65c'),
self.stash_repository.commit(ref='bae5d1e90999')
],
self.database.find_commits_in_range(repository_id='safari',
branch='main',
limit=2),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_all_commits_svn(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(
4,
len(
self.database.find_commits_in_range(repository_id='webkit',
branch='main')))
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',
limit=2),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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]))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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]))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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'),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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,
fast=False)
self.assertEqual(
[self.svn_repository.commit(ref=6)],
self.database.find_commits_by_ref(repository_id='webkit',
ref=6),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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'))
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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'),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_previous_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.svn_repository.commit(ref=4),
self.database.previous_commit(
self.svn_repository.commit(ref=6)),
)
self.assertEqual(
self.stash_repository.commit(ref='bae5d1e90999'),
self.database.previous_commit(
self.stash_repository.commit(ref='d8bce26fa65c')),
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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': []},
)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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)
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
def test_branch_keys_for_commits(self,
redis=StrictRedis,
cassandra=CassandraContext):
with MockModelFactory.safari(), MockModelFactory.webkit():
self.init_database(redis=redis, cassandra=cassandra)
branches = self.database.branch_keys_for_commits([
self.stash_repository.commit(ref='d8bce26fa65c'),
self.svn_repository.commit(ref=6),
])
self.assertEqual(branches, ['default'])
branches = self.database.branch_keys_for_commits([
self.stash_repository.commit(ref='621652add7fc'),
self.svn_repository.commit(ref=7),
])
self.assertEqual(branches, ['branch-a'])
branches = self.database.branch_keys_for_commits([
self.stash_repository.commit(ref='790725a6d79e'),
self.svn_repository.commit(ref=8),
])
self.assertEqual(branches, ['branch-b'])
@WaitForDockerTestCase.mock_if_no_docker(
mock_redis=FakeStrictRedis, mock_cassandra=MockCassandraContext)
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__(self, **kwargs):
_SVNMock.__init__(self, name='webkit')
WebKitRepository.__init__(self, **kwargs)