def test_current_commit_is_HEAD_ref_in_repo():
repo = MemoryRepo()
tree = Tree()
repo.do_commit(tree=tree.id, message=b'first commit')
commit = repo.do_commit(tree=tree.id, message=b'second commit')
assert GitRepo(repo).current_commit.id == commit
def test(self):
# TODO This test needs to be broken up.
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data(
'a',
b'file a',
)
self.assertEqual(b'file a', writer.get('a').data)
writer.commit('Add a.')
self.assertEqual(b'file a', writer.get('a').data)
self.assertEqual(b'file a', TreeReader(repo).get('a').data)
writer.set_data(
'b/c',
b'file c',
)
writer.commit('Add b/c.')
self.assertEqual(b'file c', writer.get('b/c').data)
writer.set_data(
'b/c',
b'file c ver 2',
)
writer.commit('Modify b/c.')
self.assertEqual(b'file c ver 2', writer.get('b/c').data)
writer.remove('a')
writer.commit('Remove a.')
self.assertFalse(writer.exists('a'))
writer.remove('b/c')
writer.commit('Remove b/c.')
self.assertFalse(writer.exists('b/c'))
def test_fetch_pack_none(self):
c = LocalGitClient()
s = open_repo('a.git')
self.addCleanup(tear_down_repo, s)
out = BytesIO()
walker = MemoryRepo().get_graph_walker()
ret = c.fetch_pack(
s.path,
lambda heads: [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
graph_walker=walker,
pack_data=out.write)
self.assertEqual({b'HEAD': b'refs/heads/master'}, ret.symrefs)
self.assertEqual(
{
b'HEAD':
b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
b'refs/heads/master':
b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
b'refs/tags/mytag':
b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
b'refs/tags/mytag-packed':
b'b0931cadc54336e78a1d980420e3268903b57a50'
}, ret.refs)
# Hardcoding is not ideal, but we'll fix that some other day..
self.assertTrue(
out.getvalue().startswith(b'PACK\x00\x00\x00\x02\x00\x00\x00\x07'))
def setUp(self):
super(GitImportProcessorTests, self).setUp()
self.repo = MemoryRepo()
try:
from dulwich.fastexport import GitImportProcessor
except ImportError:
raise SkipTest("python-fastimport not available")
self.processor = GitImportProcessor(self.repo)
def test_rm_non_existant(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('a/b', b'b')
with self.assertRaises(KeyError):
writer.remove('a/c')
writer.set_data('a/d', b'd')
def test_ff(self):
r = MemoryRepo()
base = make_commit()
c1 = make_commit(parents=[base.id])
c2 = make_commit(parents=[c1.id])
r.object_store.add_objects([(base, None), (c1, None), (c2, None)])
self.assertTrue(can_fast_forward(r, c1.id, c1.id))
self.assertTrue(can_fast_forward(r, base.id, c1.id))
self.assertTrue(can_fast_forward(r, c1.id, c2.id))
self.assertFalse(can_fast_forward(r, c2.id, c1.id))
def test_current_tree_should_be_from_current_commit():
repo = MemoryRepo()
tree = Tree()
repo.object_store.add_object(tree)
repo.do_commit(tree=tree.id, message=b'first commit')
tree.add(b'test', 0o100644, Blob().id)
repo.object_store.add_object(tree)
repo.do_commit(tree=tree.id, message=b'second commit')
assert GitRepo(repo).current_tree.id == tree.id
async def test_from_load_with_routes_old(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.set_data('events/test_event/routes', b'\x91\x81\xa6points\x90')
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
self.assertEqual(event.routes, [{'points': []}])
def test_fetch_pack_none(self):
c = LocalGitClient()
s = open_repo('a.git')
out = BytesIO()
walker = MemoryRepo().get_graph_walker()
c.fetch_pack(s.path,
lambda heads: ["a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
graph_walker=walker, pack_data=out.write)
# Hardcoding is not ideal, but we'll fix that some other day..
self.assertTrue(out.getvalue().startswith('PACK\x00\x00\x00\x02\x00\x00\x00\x07'))
def __init__(self, url):
""" initialize dulwich magic """
self.repo_url = url
# We have two repository handles, one for reading and one for writing.
self.rorepo = MemoryRepo()
self.rwrepo = MemoryRepo()
self.rorepo.refs.set_symbolic_ref(b'HEAD', b'refs/heads/master')
self.rwrepo.refs.set_symbolic_ref(b'HEAD', b'refs/heads/master')
porcelain.fetch(self.rorepo, self.repo_url)
porcelain.fetch(self.rwrepo, self.repo_url)
self.rorepo[b'refs/heads/master'] = self.rorepo[
b'refs/remotes/origin/master']
self.rwrepo[b'refs/heads/master'] = self.rwrepo[
b'refs/remotes/origin/master']
self.rotree = self.rorepo[self.rorepo[b'HEAD'].tree]
self.rwtree = self.rwrepo[self.rwrepo[b'HEAD'].tree]
async def test_save_no_routes_before_and_after(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
app, settings = get_test_app_and_settings(repo)
event = Event(app, 'test_event', {'title': 'Test event'}, [])
await event.save('save test_event',
tree_writer=writer,
save_routes=True)
self.assertFalse(writer.exists('events/test_event/routes'))
def test_diverged(self):
r = MemoryRepo()
base = make_commit()
c1 = make_commit(parents=[base.id])
c2a = make_commit(parents=[c1.id], message=b"2a")
c2b = make_commit(parents=[c1.id], message=b"2b")
r.object_store.add_objects([(base, None), (c1, None), (c2a, None),
(c2b, None)])
self.assertTrue(can_fast_forward(r, c1.id, c2a.id))
self.assertTrue(can_fast_forward(r, c1.id, c2b.id))
self.assertFalse(can_fast_forward(r, c2a.id, c2b.id))
self.assertFalse(can_fast_forward(r, c2b.id, c2a.id))
async def test_from_load(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '''
title: Test event
'''.encode())
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
self.assertEqual(event.config, {'title': 'Test event'})
self.assertEqual(event.routes, [])
def test_get_object():
data = create_data('sample/data.yml', 'test content')
data2 = create_data('sample2/data2.yml', 'test content2')
data3 = create_data('sample2/data3.yml', 'test content3')
message = 'commit message'
author = 'commit author'
repo = MemoryRepo()
git_repo = GitRepo(repo)
git_repo.commit([data, data2, data3], message, author)
assert git_repo.get_object('sample/data.yml') == 'test content'
async def test_load_events(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
await load_events(app, writer)
events = app['trackers.events']
self.assertEqual(len(events), 1)
event = events['test_event']
self.assertEqual(event.name, 'test_event')
async def test_start_json(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.set_data('events/test_event/test_rider', '[]'.encode())
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
tracker = await static_start_event_tracker(app, event, 'Test rider', {'name': 'test_rider', 'format': 'json'},
None, None)
await tracker.complete()
self.assertEqual(tracker.points, [])
def test_list():
data = create_data('sample/data.yml', 'test content')
data2 = create_data('sample2/data2.yml', 'test content2')
data3 = create_data('sample2/data3.yml', 'test content3')
message = 'commit message'
author = 'commit author'
repo = MemoryRepo()
git_repo = GitRepo(repo)
git_repo.commit([data, data2, data3], message, author)
assert all([
elem in ['test content2', 'test content3']
for elem in git_repo.list('sample2/')
])
async def tracker_web_server_fixture():
with tempfile.TemporaryDirectory() as cache_path:
repo = MemoryRepo()
settings = {
'google_api_key':
TEST_GOOGLE_API_KEY,
'cache_path':
cache_path,
'oauth_providers': [],
'app_url':
'',
'aiosession_encryption_key':
'kOKJegsEmRHdOSKsIEW9IiQdB3B6ZaKCx_F6rGfdY2g=',
}
async def mock_app_setup(app, settings):
app['trackers.settings'] = settings
app['trackers.data_repo'] = repo
app['trackers.events'] = {}
app['analyse_processing_lock'] = asyncio.Lock()
app['start_event_trackers'] = {
'mock': None,
}
return AsyncExitStack()
client_errors = []
static_path = pkg_resources.resource_filename('trackers', '/static')
async def client_error(request):
body = await request.text()
body = convert_client_urls_to_paths(static_path, body)
sys.stderr.write(body + '\n')
client_errors.append(body)
return web.Response()
server_errors = []
def exception_recorder():
exc_info = sys.exc_info()
server_errors.append(exc_info)
traceback.print_exception(*exc_info)
app = await make_aio_app(settings,
app_setup=mock_app_setup,
client_error_handler=client_error,
exception_recorder=exception_recorder)
yield app, client_errors, server_errors
async def test_save_no_routes(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.set_data('events/test_event/routes', b'\x91\x81\xa6points\x90')
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
event.routes.pop()
await event.save('save test_event',
tree_writer=writer,
save_routes=True)
self.assertFalse(writer.exists('events/test_event/routes'))
def __init__(self, uri):
self._client, self._host_path = get_transport_and_path(uri)
# Choose repo
if HAS_REDIS and getUtility(IRepositoryManager).redis is not None:
self._repo = RedisRepo(redis=getUtility(IRepositoryManager).redis,
prefix=uri)
else:
self._repo = MemoryRepo()
# Set HTTP Basic Authorization header when available and supported
product_config = getattr(getConfiguration(), 'product_config', {})
my_config = product_config.get('collective.gitresource', {})
if uri in my_config and isinstance(self._client, HttpGitClient):
self._client.opener.addheaders.append(
'Authorization',
'Basic {0:s}'.format(my_config[uri].encode('base64').strip()))
def determine_wants(haves):
wants = dict([
(r, s) for (r, s) in haves.iteritems()
if not r.endswith("^{}") and (r == 'HEAD' or r.startswith(
'refs/heads')) and not s == ZERO_SHA
])
assert wants, 'No heads found. Cannot continue without any.'
new_heads = [
s for s in wants.values() if s not in self._repo.object_store
]
# MemoRepo needs always at least one head to work
return set(new_heads) or [wants.get('HEAD', wants.values()[0])]
# Do initial fetch
refs = self._client.fetch(self._host_path,
self._repo,
determine_wants=determine_wants,
progress=logger.info)
# Update only those heads, which have been fetched from remote
for ref, sha in refs.items():
if sha in self._repo.object_store:
self._repo.refs[ref] = sha
# Init branches
branches = dict([(name.split('/')[-1], Head(self, ref, name))
for name, ref in refs.items()
if name.startswith('refs/heads')])
# Finish init
super(Repository, self).__init__(branches)
async def test_from_load_with_routes(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
self.assertFalse(writer.exists('events/test_event/routes'))
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.set_data('events/test_event/routes.yaml',
'- {data_hash: abcd, name: foo}'.encode())
writer.set_data('events/test_event/routes_data/abcd',
b'\x81\xa6points\x90')
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
self.assertEqual(event.routes, [{'name': 'foo', 'points': []}])
async def test_start_msgpack(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', '{}'.encode())
writer.set_data('events/test_event/test_rider', b'\x91\x82\xa4time\xcbA\xd6\x1a\n\x98\x00\x00\x00\xa3bar\xa3foo')
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
event = await Event.load(app, 'test_event', writer)
tracker = await static_start_event_tracker(app, event, 'Test rider', {'name': 'test_rider', 'format': 'msgpack'},
None, None)
await tracker.complete()
self.assertEqual(len(tracker.points), 1)
self.assertEqual(tracker.points[0], {
'time': datetime.datetime(2017, 1, 1),
'bar': 'foo',
})
def do_setup(self, data):
repo = MemoryRepo()
cache_dir = self.useFixture(fixtures.TempDir())
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', dedent(data).encode())
writer.commit('add test_event')
async def start_mock_event_tracker(app, event, rider_name,
tracker_data, start, end):
tracker = Tracker('mock_tracker')
tracker.completed.set_result(None)
return tracker
app, settings = get_test_app_and_settings(repo)
settings['cache_path'] = cache_dir.path
app['start_event_trackers'] = {
'mock': start_mock_event_tracker,
}
return app, settings, writer
async def test_implicit_static(self):
data = '''
tracker_end: 2019-01-01 00:00:00
riders:
- name: foo
static_analyse: True
'''
repo = MemoryRepo()
cache_dir = self.useFixture(fixtures.TempDir())
writer = TreeWriter(repo)
writer.set_data('events/test_event/data.yaml', dedent(data).encode())
writer.set_data('events/test_event/static/foo/source',
msgpack.dumps([{
'foo': 'bar'
}], default=json_encode))
writer.set_data(
'events/test_event/static/foo/analyse',
msgpack.dumps([{
'foo': 'bar',
'speed': 1
}], default=json_encode))
writer.set_data('events/test_event/static/foo/off_route',
msgpack.dumps([], default=json_encode))
writer.commit('add test_event')
app, settings = get_test_app_and_settings(repo)
settings['cache_path'] = cache_dir.path
event = await Event.load(app, 'test_event', writer)
await event.start_trackers()
rider_objects = event.riders_objects['foo']
self.assertEqual(rider_objects.source_trackers[0].points, [{
'foo': 'bar'
}])
self.assertEqual(rider_objects.analyse_tracker.points, [{
'foo': 'bar',
'speed': 1
}])
await event.stop_and_complete_trackers()
def setUp(self):
super(GraftsInMemoryRepoTests, self).setUp()
r = self._repo = MemoryRepo()
self._shas = []
tree = Tree()
commit_kwargs = {
'committer': 'Test Committer <*****@*****.**>',
'author': 'Test Author <*****@*****.**>',
'commit_timestamp': 12395,
'commit_timezone': 0,
'author_timestamp': 12395,
'author_timezone': 0,
'tree': tree.id
}
self._shas.append(r.do_commit('empty commit', **commit_kwargs))
self._shas.append(r.do_commit('empty commit', **commit_kwargs))
self._shas.append(r.do_commit('empty commit', **commit_kwargs))
def test_commit_new_data():
data = create_data('sample/data.yml', 'test content')
data2 = create_data('sample2/data2.yml', 'test content2')
data3 = create_data('sample2/data3.yml', 'test content3')
message = 'commit message'
author = 'commit author'
repo = MemoryRepo()
git_repo = GitRepo(repo)
git_repo.commit([data, data2, data3], message, author)
assert sorted(list(git_repo.current_tree)) == [b'sample', b'sample2']
assert git_repo.current_commit.message == message.encode('utf8')
assert git_repo.current_commit.author.startswith(author.encode('utf8'))
assert repo.get_object(
repo.get_object(git_repo.current_tree[b'sample'][1])[b'data.yml']
[1]).data == b'test content'
assert repo.get_object(
repo.get_object(git_repo.current_tree[b'sample2'][1])[b'data2.yml']
[1]).data == b'test content2'
assert repo.get_object(
repo.get_object(git_repo.current_tree[b'sample2'][1])[b'data3.yml']
[1]).data == b'test content3'
async def test_save(self):
repo = MemoryRepo()
writer = TreeWriter(repo)
app, settings = get_test_app_and_settings(repo)
event = Event(app, 'test_event', {'title': 'Test event'}, [{
'title': 'foobar',
'points': []
}])
await event.save('save test_event',
tree_writer=writer,
save_routes=True)
self.assertEqual(
writer.get('events/test_event/data.yaml').data.decode(),
'title: Test event\n')
self.assertEqual(
writer.get('events/test_event/routes.yaml').data.decode(),
'- title: foobar\n data_hash: KhGSreKJpp4AwDUWjtATeuAYLms=\n')
self.assertEqual(
writer.get(
'events/test_event/routes_data/KhGSreKJpp4AwDUWjtATeuAYLms=').
data, b'\x81\xa6points\x90')
def test_fetch_into_empty(self):
c = LocalGitClient()
t = MemoryRepo()
s = open_repo('a.git')
self.addCleanup(tear_down_repo, s)
self.assertEqual(s.get_refs(), c.fetch(s.path, t))
def test_commit_by_sha(self):
r = MemoryRepo()
c1, c2, c3 = build_commit_graph(r.object_store, [[1], [2, 1],
[3, 1, 2]])
self.assertEqual([c1], list(parse_commit_range(r, c1.id)))
def test_nonexistent(self):
r = MemoryRepo()
self.assertRaises(KeyError, parse_commit_range, r, "thisdoesnotexist")
