def test_fs_state_tracked(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
tracked = FSProjectStateResources(plugin, pootle_path=pootle_path, fs_path=fs_path).tracked
assert list(tracked.order_by("pk")) == list(qs.order_by("pk"))
def test_fs_state_resources(project0_fs_resources):
project = project0_fs_resources
plugin = DummyPlugin(project)
state_resources = FSProjectStateResources(plugin)
assert state_resources.resources is plugin.resources
# resources are cached on state and plugin
plugin.reload()
assert state_resources.resources is not plugin.resources
state_resources.reload()
assert state_resources.resources is plugin.resources
def test_fs_state_resources(project0_fs_resources):
project = project0_fs_resources
plugin = DummyPlugin(project)
state_resources = FSProjectStateResources(plugin)
assert state_resources.resources is plugin.resources
# resources are cached on state and plugin
plugin.reload()
assert state_resources.resources is not plugin.resources
state_resources.reload()
assert state_resources.resources is plugin.resources
def test_fs_state_unsynced(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
resources = FSProjectStateResources(plugin)
resources.tracked.update(last_sync_hash=None, last_sync_revision=None)
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
unsynced = FSProjectStateResources(plugin, pootle_path=pootle_path, fs_path=fs_path).unsynced
assert list(unsynced.order_by("pk")) == list(qs.order_by("pk"))
def test_fs_state_tracked(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
tracked = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).tracked
assert (list(tracked.order_by("pk")) == list(qs.order_by("pk")))
def test_fs_state_tracked_paths(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
resources = FSProjectStateResources(plugin)
resources.tracked.update(last_sync_hash=None, last_sync_revision=None)
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
resources = FSProjectStateResources(plugin)
assert (sorted(resources.tracked.values_list(
"path", "pootle_path")) == sorted(resources.tracked_paths.items()))
def test_fs_state_tracked_paths(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
resources = FSProjectStateResources(plugin)
for trackable in resources.trackable_stores:
add_store_fs(*trackable)
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
resources = FSProjectStateResources(plugin)
assert (sorted(resources.tracked.values_list(
"path", "pootle_path")) == sorted(resources.tracked_paths.items()))
def test_fs_state_unsynced(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
resources = FSProjectStateResources(plugin)
resources.tracked.update(last_sync_hash=None, last_sync_revision=None)
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
unsynced = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).unsynced
assert (list(unsynced.order_by("pk")) == list(qs.order_by("pk")))
def test_fs_state_tracked(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
resources = FSProjectStateResources(plugin)
for trackable in resources.trackable_stores:
add_store_fs(*trackable)
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
tracked = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).tracked
assert (list(tracked.order_by("pk")) == list(qs.order_by("pk")))
def test_fs_state_trackable_tracked(dummyfs, no_complex_po_):
plugin = dummyfs
resources = FSProjectStateResources(plugin)
store_fs = resources.tracked[0]
store = store_fs.store
store_fs.delete()
trackable = resources.trackable_stores
store = plugin.resources.stores.get(pootle_path=store.pootle_path)
assert len(trackable) == 1
assert trackable[0][0] == store
assert (trackable[0][1] == plugin.get_fs_path(store.pootle_path))
def test_fs_state_trackable_store_paths(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
qs = Store.objects.filter(translation_project__project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
resources = FSProjectStateResources(plugin)
assert (sorted((store.pootle_path, fs_path)
for store, fs_path in resources.trackable_stores) == sorted(
resources.trackable_store_paths.items()))
def test_fs_state_pootle_changed(fs_path_qs, dummyfs):
(qfilter, pootle_path, fs_path) = fs_path_qs
plugin = dummyfs
resources = FSProjectStateResources(plugin)
assert list(
FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).pootle_changed) == []
for store_fs in plugin.resources.tracked:
store_fs.last_sync_revision = store_fs.last_sync_revision - 1
store_fs.save()
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
resources = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path)
assert (sorted(resources.pootle_changed.values_list(
"pk", flat=True)) == sorted(qs.values_list("pk", flat=True)))
def test_fs_state_trackable_tracked(project0_dummy_plugin):
plugin = project0_dummy_plugin
project = plugin.project
stores = Store.objects.filter(translation_project__project=project)
store = stores[0]
# the Store is not trackable if its got a StoreFS
add_store_fs(store, plugin.get_fs_path(store.pootle_path))
trackable = FSProjectStateResources(plugin).trackable_stores
qs = stores.exclude(pootle_path=store.pootle_path)
assert (sorted(trackable, key=lambda item: item[0].pk) == [
(s, plugin.get_fs_path(s.pootle_path)) for s in list(qs.order_by("pk"))
])
def test_fs_state_trackable(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
qs = Store.objects.filter(translation_project__project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
trackable = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).trackable_stores
assert (sorted(trackable, key=lambda item: item[0].pk) == [
(store, plugin.get_fs_path(store.pootle_path))
for store in list(qs.order_by("pk"))
])
def test_fs_state_pootle_changed(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
resources = FSProjectStateResources(plugin)
for trackable in resources.trackable_stores:
add_store_fs(*trackable, synced=True)
assert list(
FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path).pootle_changed) == []
stores = Store.objects.filter(translation_project__project=plugin.project)
for store in stores.all():
unit = store.units.first()
unit.target = "%s FOO!" % store.name
unit.save()
qs = StoreFS.objects.filter(project=plugin.project)
if qfilter is False:
qs = qs.none()
elif qfilter:
qs = qs.filter(qfilter)
resources = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path)
assert (sorted(resources.pootle_changed.values_list(
"pk", flat=True)) == sorted(qs.values_list("pk", flat=True)))
def test_fs_state_unsynced_staged(project0_dummy_plugin):
plugin = project0_dummy_plugin
resources = FSProjectStateResources(plugin)
store_fs = add_store_fs(*resources.trackable_stores[0])
assert resources.unsynced.count() == 1
# unsynced does not include any that are staged rm/merge
store_fs.staged_for_merge = True
store_fs.save()
assert resources.unsynced.count() == 0
store_fs.staged_for_merge = False
store_fs.staged_for_removal = True
store_fs.save()
assert resources.unsynced.count() == 0
store_fs.staged_for_removal = False
store_fs.save()
assert resources.unsynced.count() == 1
def test_fs_state_found_file_matches(fs_path_queries):
plugin, (qfilter, pootle_path, fs_path) = fs_path_queries
resources = FSProjectStateResources(plugin,
pootle_path=pootle_path,
fs_path=fs_path)
stores = resources.resources.stores
found_files = []
for pp in stores.values_list("pootle_path", flat=True):
fp = plugin.get_fs_path(pp)
if fs_path and not fnmatch(fp, fs_path):
continue
if pootle_path and not fnmatch(pp, pootle_path):
continue
found_files.append((pp, fp))
assert (sorted(resources.found_file_matches) == sorted(found_files))
assert (resources.found_file_paths == [
x[1] for x in resources.found_file_matches
])
def test_fs_state_synced_staged(dummyfs):
plugin = dummyfs
resources = FSProjectStateResources(plugin)
store_fs = resources.tracked[0]
resources.tracked.exclude(pk=store_fs.pk).update(last_sync_hash=None,
last_sync_revision=None)
assert resources.synced.count() == 1
# synced does not include any that are staged rm/merge
store_fs.staged_for_merge = True
store_fs.save()
assert resources.synced.count() == 0
store_fs.staged_for_merge = False
store_fs.staged_for_removal = True
store_fs.save()
assert resources.synced.count() == 0
store_fs.staged_for_removal = False
store_fs.save()
assert resources.synced.count() == 1
