def test_install_update(httpserver, info):
"""Update is installed"""
# Clear any cached data
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data('__workflow_update_status') is None
with fakeresponse(httpserver, DATA_JSON, HTTP_HEADERS_JSON):
# No update for latest release
assert update.install_update(TEST_REPO_SLUG, RELEASE_LATEST) is False
# Check for updates
assert update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT) is True
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
assert update.install_update(TEST_REPO_SLUG,
RELEASE_CURRENT) is True
assert c.cmd[0] == 'open'
assert c.cmd[1].endswith('.alfredworkflow')
assert wf.cached_data('__workflow_update_status')['available'] is False
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertIsNone(wf.cached_data('__workflow_update_status'))
self.assertFalse(update.install_update(TEST_REPO_SLUG,
RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(update.install_update(TEST_REPO_SLUG,
RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(wf.cached_data(
'__workflow_update_status')['available'])
def test_magic_args(alfred4):
"""Magic args"""
# cache original sys.argv
oargs = sys.argv[:]
# delsettings
sys.argv = [oargs[0]] + [b'workflow:delsettings']
try:
wf = Workflow(default_settings={'arg1': 'value1'})
assert wf.settings['arg1'] == 'value1'
assert os.path.exists(wf.settings_path)
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.settings_path)
finally:
sys.argv = oargs[:]
# delcache
sys.argv = [oargs[0]] + [b'workflow:delcache']
def somedata():
return {'arg1': 'value1'}
try:
wf = Workflow()
cachepath = wf.cachefile('somedir')
os.makedirs(cachepath)
wf.cached_data('test', somedata)
assert os.path.exists(wf.cachefile('test.cpickle'))
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.cachefile('test.cpickle'))
finally:
sys.argv = oargs[:]
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertIsNone(wf.cached_data('__workflow_update_status'))
self.assertFalse(update.install_update(TEST_REPO_SLUG, RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(
update.install_update(TEST_REPO_SLUG, RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(
wf.cached_data('__workflow_update_status')['available'])
def test_magic_args(alfred4):
"""Magic args"""
# cache original sys.argv
oargs = sys.argv[:]
# delsettings
sys.argv = [oargs[0]] + [b"workflow:delsettings"]
try:
wf = Workflow(default_settings={"arg1": "value1"})
assert wf.settings["arg1"] == "value1"
assert os.path.exists(wf.settings_path)
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.settings_path)
finally:
sys.argv = oargs[:]
# delcache
sys.argv = [oargs[0]] + [b"workflow:delcache"]
def somedata():
return {"arg1": "value1"}
try:
wf = Workflow()
cachepath = wf.cachefile("somedir")
os.makedirs(cachepath)
wf.cached_data("test", somedata)
assert os.path.exists(wf.cachefile("test.pickle"))
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.cachefile("test.pickle"))
finally:
sys.argv = oargs[:]
def test_install_update(httpserver, info):
"""Update is installed"""
# Clear any cached data
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data('__workflow_update_status') is None
with fakeresponse(httpserver, DATA_JSON, HTTP_HEADERS_JSON):
# No update for latest release
assert update.install_update(TEST_REPO_SLUG, RELEASE_LATEST) is False
# Check for updates
assert update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT) is True
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
assert update.install_update(TEST_REPO_SLUG,
RELEASE_CURRENT) is True
assert c.cmd[0] == 'open'
assert c.cmd[1].endswith('.alfredworkflow')
assert wf.cached_data(
'__workflow_update_status')['available'] is False
def test_magic_args(alfred4):
"""Magic args"""
# cache original sys.argv
oargs = sys.argv[:]
# delsettings
sys.argv = [oargs[0]] + [b'workflow:delsettings']
try:
wf = Workflow(default_settings={'arg1': 'value1'})
assert wf.settings['arg1'] == 'value1'
assert os.path.exists(wf.settings_path)
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.settings_path)
finally:
sys.argv = oargs[:]
# delcache
sys.argv = [oargs[0]] + [b'workflow:delcache']
def somedata():
return {'arg1': 'value1'}
try:
wf = Workflow()
cachepath = wf.cachefile('somedir')
os.makedirs(cachepath)
wf.cached_data('test', somedata)
assert os.path.exists(wf.cachefile('test.cpickle'))
with pytest.raises(SystemExit):
wf.args
assert not os.path.exists(wf.cachefile('test.cpickle'))
finally:
sys.argv = oargs[:]
def main():
wf = Workflow()
error = None
try:
# initialize client
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
since = wf.cached_data('pocket_since', max_age=0) or 0
links = wf.cached_data('pocket_list', max_age=0) or {}
next_since = 0
offset = 0
while True:
get = pocket_instance.get(
detailType='complete',
since=since,
state='all',
count=LINK_LIMIT,
offset=offset
)[0]
data = get['list']
next_since = get['since']
if get['status'] != 1 or len(data) == 0:
break
links.update(data)
offset += LINK_LIMIT
# Delete obsolete entries
for item_id in links.keys():
if links[item_id]['status'] == '2':
del links[item_id]
wf.cache_data('pocket_since', next_since)
wf.cache_data('pocket_list', links)
tags = list(set([t for l in links.values() if 'tags' in l
for t in l['tags'].keys()]))
wf.cache_data('pocket_tags', tags)
# update fulltext search index
for item_id in links.keys():
url = links[item_id]['given_url']
if not FullText.has_link(url):
FullText.get_instance().add_page(url)
time.sleep(.1)
except (AuthException, URLError, PocketException, PasswordNotFound), e:
error = type(e).__name__
wf.cache_data('pocket_error', error)
# delete token if authentication failed
if error == 'AuthException':
wf.delete_password('pocket_access_token')
def main():
wf = Workflow()
error = None
try:
# initialize client
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
state = None
since = wf.cached_data('pocket_since', max_age=0) or 0
links = {}
# fetch cached links if since is not 0
if since > 0:
links = wf.cached_data('pocket_list', max_age=0) or {}
# Only use delta syncing if dict is not empty
if links:
state = 'all'
next_since = 0
offset = 0
while True:
get = pocket_instance.get(
sort='newest',
detailType='complete',
since=since,
state=state,
count=LINK_LIMIT,
offset=offset
)[0]
data = get['list']
next_since = get['since']
if get['status'] != 1 or len(data) == 0:
break
links = sync_data(links, data)
offset += LINK_LIMIT
wf.cache_data('pocket_since', next_since)
wf.cache_data('pocket_list', links)
except (AuthException, URLError, PocketException, PasswordNotFound), e:
error = type(e).__name__
wf.cache_data('pocket_error', error)
# delete token if authentication failed
if error == 'AuthException':
wf.delete_password('pocket_access_token')
def main():
wf = Workflow()
error = None
try:
# initialize client
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
since = wf.cached_data('pocket_since', max_age=0) or 0
links = wf.cached_data('pocket_list', max_age=0) or {}
next_since = 0
offset = 0
while True:
get = pocket_instance.get(
detailType='complete',
since=since,
state='all',
count=LINK_LIMIT,
offset=offset
)[0]
data = get['list']
next_since = get['since']
if get['status'] != 1 or len(data) == 0:
break
links.update(data)
offset += LINK_LIMIT
# Delete obsolete entries
for item_id in links.keys():
if links[item_id]['status'] == '2':
del links[item_id]
wf.cache_data('pocket_since', next_since)
wf.cache_data('pocket_list', links)
tags = list(set([t for l in links.values() if 'tags' in l
for t in l['tags'].keys()]))
wf.cache_data('pocket_tags', tags)
except (AuthException, URLError, PocketException, PasswordNotFound), e:
error = type(e).__name__
wf.cache_data('pocket_error', error)
# delete token if authentication failed
if error == 'AuthException':
wf.delete_password('pocket_access_token')
def test_check_update(httpserver, infopl, alfred4):
"""Check update"""
key = "__workflow_latest_version"
tests = [
# data, alfred version, pre, expected value
(RELEASES_JSON, None, False, True),
(RELEASES_JSON, "3", False, True),
(RELEASES_4PLUS_JSON, None, False, True),
(RELEASES_4PLUS_JSON, "3", False, False),
(RELEASES_4PLUS_JSON, "3", True, False),
]
for data, alfred, pre, wanted in tests:
wf = Workflow()
wf.reset()
with fakeresponse(httpserver, data, HTTP_HEADERS_JSON):
v = update.check_update(TEST_REPO, RELEASE_CURRENT, pre, alfred)
assert v == wanted, "unexpected update status"
status = wf.cached_data(key)
assert status is not None
assert status["available"] == wanted
assert wf.update_available == wanted
if wanted: # other data may not be set if available is False
v = update.check_update(TEST_REPO, status["version"], pre,
alfred)
assert v is False
def test_check_update(httpserver, infopl, alfred4):
"""Check update"""
key = '__workflow_latest_version'
tests = [
# data, alfred version, pre, expected value
(RELEASES_JSON, None, False, True),
(RELEASES_JSON, '3', False, True),
(RELEASES_4PLUS_JSON, None, False, True),
(RELEASES_4PLUS_JSON, '3', False, False),
(RELEASES_4PLUS_JSON, '3', True, False),
]
for data, alfred, pre, wanted in tests:
wf = Workflow()
wf.reset()
with fakeresponse(httpserver, data, HTTP_HEADERS_JSON):
v = update.check_update(TEST_REPO, RELEASE_CURRENT,
pre, alfred)
assert v == wanted, "unexpected update status"
status = wf.cached_data(key)
assert status is not None
assert status['available'] == wanted
assert wf.update_available == wanted
if wanted: # other data may not be set if available is False
v = update.check_update(TEST_REPO, status['version'],
pre, alfred)
assert v is False
def test_workflow_update_methods(self):
"""Workflow update methods"""
def fake(wf):
return
Workflow().reset()
# Initialise with outdated version
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
})
wf.run(fake)
# Check won't have completed yet
self.assertFalse(wf.update_available)
# wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
time.sleep(1)
# There *is* a newer version in the repo
self.assertTrue(wf.update_available)
# Mock out subprocess and check the correct command is run
c = WorkflowMock()
with c:
self.assertTrue(wf.start_update())
# wf.logger.debug('start_update : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
# Grab the updated release data, then reset the cache
update_info = wf.cached_data('__workflow_update_status')
wf.reset()
# Initialise with latest available release
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': update_info['version'],
})
wf.run(fake)
# Wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# Remote version is same as the one we passed to Workflow
self.assertFalse(wf.update_available)
self.assertFalse(wf.start_update())
def test_workflow_update_methods(self):
"""Workflow update methods"""
def fake(wf):
return
Workflow().reset()
# Initialise with outdated version
wf = Workflow(update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
})
wf.run(fake)
# Check won't have completed yet
self.assertFalse(wf.update_available)
# wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
time.sleep(1)
# There *is* a newer version in the repo
self.assertTrue(wf.update_available)
# Mock out subprocess and check the correct command is run
c = WorkflowMock()
with c:
self.assertTrue(wf.start_update())
# wf.logger.debug('start_update : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
# Grab the updated release data, then reset the cache
update_info = wf.cached_data('__workflow_update_status')
wf.reset()
# Initialise with latest available release
wf = Workflow(update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': update_info['version'],
})
wf.run(fake)
# Wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# Remote version is same as the one we passed to Workflow
self.assertFalse(wf.update_available)
self.assertFalse(wf.start_update())
def main():
wf = Workflow()
error = None
try:
# initialize client
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
since = wf.cached_data('pocket_since', max_age=0) or 0
links = wf.cached_data('pocket_list', max_age=0) or {}
next_since = 0
offset = 0
while True:
get = pocket_instance.get(detailType='complete',
since=since,
state='all',
count=LINK_LIMIT,
offset=offset)[0]
data = get['list']
next_since = get['since']
if get['status'] != 1 or len(data) == 0:
break
links.update(data)
offset += LINK_LIMIT
# Delete obsolete entries
for item_id in links.keys():
if links[item_id]['status'] == '2':
del links[item_id]
wf.cache_data('pocket_since', next_since)
wf.cache_data('pocket_list', links)
except (AuthException, URLError, PocketException, PasswordNotFound), e:
error = type(e).__name__
wf.cache_data('pocket_error', error)
# delete token if authentication failed
if error == 'AuthException':
wf.delete_password('pocket_access_token')
def test_no_auto_update(info):
"""No update check"""
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data('__workflow_update_status') is None
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf = Workflow()
wf.args
assert wf.settings.get('__workflow_autoupdate') is False
assert wf.cached_data('__workflow_update_status') is None
c = WorkflowMock()
with c:
wf = Workflow(update_settings={
'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT
})
assert wf.cached_data('__workflow_update_status') is None
def test_no_auto_update(info):
"""No update check."""
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data('__workflow_update_status') is None
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf = Workflow()
wf.args
assert wf.settings.get('__workflow_autoupdate') is False
assert wf.cached_data('__workflow_update_status') is None
c = WorkflowMock()
with c:
wf = Workflow(update_settings={
'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT
})
assert wf.cached_data('__workflow_update_status') is None
def test_no_auto_update(infopl, alfred4):
"""No update check."""
key = "__workflow_latest_version"
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data(key) is None
c = WorkflowMock(["script", "workflow:noautoupdate"])
with c:
wf = Workflow()
wf.args
assert wf.settings.get("__workflow_autoupdate") is False
assert wf.cached_data(key) is None
c = WorkflowMock()
with c:
wf = Workflow(update_settings={
"github_slug": TEST_REPO,
"version": RELEASE_CURRENT
})
assert wf.cached_data(key) is None
def test_check_update(httpserver, info):
"""Check update"""
wf = Workflow()
wf.reset()
with fakeresponse(httpserver, DATA_JSON, HTTP_HEADERS_JSON):
assert update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT) is True
update_info = wf.cached_data('__workflow_update_status')
assert update_info is not None
assert wf.update_available is True
assert update.check_update(TEST_REPO_SLUG,
update_info['version']) is False
def test_install_update(httpserver, infopl, alfred4):
"""Update is installed."""
key = '__workflow_latest_version'
# Clear any cached data
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data(key) is None
with fakeresponse(httpserver, RELEASES_JSON, HTTP_HEADERS_JSON):
# No update because no update status has been cached
assert update.install_update() is False
# Check for updates
v = update.check_update(TEST_REPO, RELEASE_CURRENT)
assert v is True
# Verify new workflow is downloaded and installed
with WorkflowMock() as c:
assert update.install_update() is True
assert c.cmd[0] == 'open'
assert re.search(r'\.alfred(\d+)?workflow$', c.cmd[1])
assert wf.cached_data(key)['available'] is False
# Test mangled update data
status = wf.cached_data(key)
assert status['available'] is False
assert status['download'] is None
assert status['version'] is None
# Flip available bit, but leave rest invalid
status['available'] = True
wf.cache_data(key, status)
with WorkflowMock():
assert update.install_update() is False
def test_install_update(httpserver, infopl, alfred4):
"""Update is installed."""
key = "__workflow_latest_version"
# Clear any cached data
wf = Workflow()
wf.reset()
# Assert cache was cleared
assert wf.cached_data(key) is None
with fakeresponse(httpserver, RELEASES_JSON, HTTP_HEADERS_JSON):
# No update because no update status has been cached
assert update.install_update() is False
# Check for updates
v = update.check_update(TEST_REPO, RELEASE_CURRENT)
assert v is True
# Verify new workflow is downloaded and installed
with WorkflowMock() as c:
assert update.install_update() is True
assert c.cmd[0] == "open"
assert re.search(r"\.alfred(\d+)?workflow$", c.cmd[1])
assert wf.cached_data(key)["available"] is False
# Test mangled update data
status = wf.cached_data(key)
assert status["available"] is False
assert status["download"] is None
assert status["version"] is None
# Flip available bit, but leave rest invalid
status["available"] = True
wf.cache_data(key, status)
with WorkflowMock():
assert update.install_update() is False
def test_check_update(httpserver, info):
"""Check update"""
wf = Workflow()
wf.reset()
with fakeresponse(httpserver, DATA_JSON, HTTP_HEADERS_JSON):
assert update.check_update(TEST_REPO_SLUG,
RELEASE_CURRENT) is True
update_info = wf.cached_data('__workflow_update_status')
assert update_info is not None
assert wf.update_available is True
assert update.check_update(TEST_REPO_SLUG,
update_info['version']) is False
class UpdateTests(unittest.TestCase):
def setUp(self):
self.wf = Workflow()
def test_download_workflow(self):
"""Update: Download workflow update"""
self.assertRaises(ValueError, u._download_workflow, 'http://github.com/file.zip')
local_file = u._download_workflow('https://github.com/fniephaus/alfred-pocket/releases/download/v2.1/Pocket-for-Alfred.alfredworkflow')
self.assertTrue(local_file.endswith('.alfredworkflow'))
self.assertTrue(os.path.isfile(local_file))
def test_get_api_url(self):
"""Update: Get API URL"""
url = u._get_api_url('fniephaus/alfred-workflow')
expected = 'https://api.github.com/repos/fniephaus/alfred-workflow/releases'
self.assertEquals(url, expected)
self.assertRaises(ValueError, u._get_api_url, 'fniephausalfred-workflow')
def test_extract_info(self):
"""Update: Extract release info"""
releases = [{
'tag_name': 'v1.2',
'assets': [{
'browser_download_url': 'https://github.com/'
}]
}]
(version, url) = u._extract_info(releases)
self.assertEquals(version, 'v1.2')
self.assertEquals(url, 'https://github.com/')
self.assertRaises(IndexError, u._extract_info, [])
del releases[0]['assets']
self.assertRaises(KeyError, u._extract_info, releases)
del releases[0]['tag_name']
self.assertRaises(KeyError, u._extract_info, releases)
def test_check_update(self):
"""Update: Check update"""
self.assertTrue(u._check_update('fniephaus/alfred-pocket', 'v0.0'))
update_info = self.wf.cached_data('__workflow_update_available')
self.assertFalse(u._check_update('fniephaus/alfred-pocket', update_info['version']))
def main():
wf = Workflow()
args = parse_args(wf.args)
title = 'Add this link'
if args.add_archive:
title = 'Add and archive this link'
wf.add_item(title, arg=args.query, valid=True)
tags = wf.cached_data('pocket_tags', max_age=0)
if tags:
for tag in tags:
if args.query:
autocomplete = '%s, #%s' % (args.query, tag)
else:
autocomplete = '#%s' % tag
wf.add_item(' > Add #%s' % tag,
autocomplete=autocomplete,
valid=False)
wf.send_feedback()
# Store Notes
n = Note.create(uuid=meta["uuid"],
title=meta["title"],
notebook=nb_name,
last_modified=datetime.datetime.fromtimestamp(
meta["updated_at"]))
NoteIndex.insert({
NoteIndex.docid: n.id,
NoteIndex.uuid: n.uuid,
NoteIndex.title: n.title,
NoteIndex.content: full_content
}).execute()
# Store tags
for tag in tagset:
Tags.create(note=n, tag=tag)
#for snip in snippets:
# s = Snippets.create(note = n.id, language = snip["language"])
# SnippetsIndex.insert({
# SnippetsIndex.docid: s.id,
# SnippetsIndex.uuid: n.uuid,
# SnippetsIndex.title: n.title,
# SnippetsIndex.content: snip["data"]
# }).execute()
def item():
return 1
wf.cached_data('update_db', item, max_age=10)
def is_dark():
return min([int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')]) < 128
if __name__ == '__main__':
from cask_actions import ACTIONS
if WF.update_available:
WF.add_item(
"An update is available!",
autocomplete='workflow:update',
valid=False,
icon=get_icon("cloud-download")
)
if WF.cached_data('cask_not_installed', cask_not_installed, max_age=0):
WF.add_item(
'Cask does not seem to be installed!',
'Hit enter to see what you need to do...',
arg='open http://caskroom.io/ && exit',
valid=True,
icon='cask.png'
)
WF.add_item(
'I trust this workflow',
'Hit enter to install cask...',
arg='brew install caskroom/cask/brew-cask',
valid=True,
icon='cask.png'
)
# delete cached file
class UpdateTests(unittest.TestCase):
def setUp(self):
create_info_plist()
self.wf = Workflow()
def tearDown(self):
delete_info_plist()
def test_download_workflow(self):
"""Update: Download workflow update"""
self.assertRaises(ValueError, update.download_workflow, URL_BAD)
local_file = update.download_workflow(URL_DL)
self.assertTrue(local_file.endswith('.alfredworkflow'))
self.assertTrue(os.path.isfile(local_file))
def test_valid_api_url(self):
"""Update: API URL for valid slug"""
url = update.build_api_url(TEST_REPO_SLUG)
self.assertEquals(url, RELEASES_URL)
def test_invalid_api_url(self):
"""Update: API URL for invalid slug"""
self.assertRaises(ValueError, update.build_api_url,
'fniephausalfred-workflow')
def test_empty_repo(self):
"""Update: no releases"""
self.assertRaises(ValueError, update.check_update, EMPTY_REPO_SLUG,
'1.0')
self.assertEquals(len(update.get_valid_releases(EMPTY_REPO_SLUG)), 0)
def test_valid_releases(self):
"""Update: valid releases"""
releases = update.get_valid_releases(TEST_REPO_SLUG)
# Right number of valid releases
self.assertEquals(len(releases), 3)
# Invalid releases are not in list
versions = [d['version'] for d in releases]
for v in RELEASES_INVALID:
self.assertFalse(v in versions)
# Correct latest release
self.assertEquals(update.Version(releases[0]['version']),
update.Version(RELEASE_LATEST))
def test_version_formats(self):
"""Update: version formats"""
# Up-to-date versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, '6.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v6.0'))
# Old versions
self.assertTrue(update.check_update(TEST_REPO_SLUG, 'v5.0'))
self.assertTrue(update.check_update(TEST_REPO_SLUG, '5.0'))
# Unknown versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v8.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, '8.0'))
def test_check_update(self):
"""Update: Check update"""
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
update_info = self.wf.cached_data('__workflow_update_status')
self.assertFalse(
update.check_update(TEST_REPO_SLUG, update_info['version']))
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertTrue(wf.cached_data('__workflow_update_status') is None)
self.assertFalse(update.install_update(TEST_REPO_SLUG, RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(
update.install_update(TEST_REPO_SLUG, RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(
wf.cached_data('__workflow_update_status')['available'])
def test_no_auto_update(self):
"""Update: no update check"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
self.assertTrue(
self.wf.cached_data('__workflow_update_status') is None)
wf = Workflow()
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf.args
self.assertFalse(wf.settings.get('__workflow_autoupdate'))
self.assertTrue(
self.wf.cached_data('__workflow_update_status') is None)
c = WorkflowMock()
with c:
wf = Workflow(update_settings={
'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT
})
self.assertTrue(
self.wf.cached_data('__workflow_update_status') is None)
def test_workflow_update_methods(self):
"""Workflow update methods"""
def fake(wf):
return
Workflow().reset()
# Initialise with outdated version
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
})
wf.run(fake)
# Check won't have completed yet
self.assertFalse(wf.update_available)
# wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
time.sleep(1)
# There *is* a newer version in the repo
self.assertTrue(wf.update_available)
# Mock out subprocess and check the correct command is run
c = WorkflowMock()
with c:
self.assertTrue(wf.start_update())
# wf.logger.debug('start_update : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
# Grab the updated release data, then reset the cache
update_info = wf.cached_data('__workflow_update_status')
wf.reset()
# Initialise with latest available release
wf = Workflow(
update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': update_info['version'],
})
wf.run(fake)
# Wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# Remote version is same as the one we passed to Workflow
self.assertFalse(wf.update_available)
self.assertFalse(wf.start_update())
class UpdateTests(unittest.TestCase):
def setUp(self):
create_info_plist()
self.wf = Workflow()
def tearDown(self):
delete_info_plist()
def test_download_workflow(self):
"""Update: Download workflow update"""
self.assertRaises(ValueError, update.download_workflow, URL_BAD)
local_file = update.download_workflow(URL_DL)
self.assertTrue(local_file.endswith('.alfredworkflow'))
self.assertTrue(os.path.isfile(local_file))
def test_valid_api_url(self):
"""Update: API URL for valid slug"""
url = update.build_api_url(TEST_REPO_SLUG)
self.assertEquals(url, RELEASES_URL)
def test_invalid_api_url(self):
"""Update: API URL for invalid slug"""
self.assertRaises(ValueError, update.build_api_url,
'fniephausalfred-workflow')
def test_empty_repo(self):
"""Update: no releases"""
self.assertRaises(ValueError, update.check_update,
EMPTY_REPO_SLUG, '1.0')
self.assertEquals(len(update.get_valid_releases(EMPTY_REPO_SLUG)), 0)
def test_valid_releases(self):
"""Update: valid releases"""
releases = update.get_valid_releases(TEST_REPO_SLUG)
# Right number of valid releases
self.assertEquals(len(releases), 3)
# Invalid releases are not in list
versions = [d['version'] for d in releases]
for v in RELEASES_INVALID:
self.assertFalse(v in versions)
# Correct latest release
self.assertEquals(update.Version(releases[0]['version']),
update.Version(RELEASE_LATEST))
def test_version_formats(self):
"""Update: version formats"""
# Up-to-date versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, '6.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v6.0'))
# Old versions
self.assertTrue(update.check_update(TEST_REPO_SLUG, 'v5.0'))
self.assertTrue(update.check_update(TEST_REPO_SLUG, '5.0'))
# Unknown versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v8.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, '8.0'))
def test_check_update(self):
"""Update: Check update"""
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
update_info = self.wf.cached_data('__workflow_update_status')
self.assertFalse(update.check_update(TEST_REPO_SLUG,
update_info['version']))
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertTrue(wf.cached_data('__workflow_update_status') is None)
self.assertFalse(update.install_update(TEST_REPO_SLUG,
RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(update.install_update(TEST_REPO_SLUG,
RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(wf.cached_data(
'__workflow_update_status')['available'])
def test_no_auto_update(self):
"""Update: no update check"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
self.assertTrue(self.wf.cached_data('__workflow_update_status') is
None)
wf = Workflow()
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf.args
self.assertFalse(wf.settings.get('__workflow_autoupdate'))
self.assertTrue(self.wf.cached_data('__workflow_update_status') is
None)
c = WorkflowMock()
with c:
wf = Workflow(update_settings={'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT})
self.assertTrue(self.wf.cached_data('__workflow_update_status') is
None)
def test_workflow_update_methods(self):
"""Workflow update methods"""
def fake(wf):
return
Workflow().reset()
# Initialise with outdated version
wf = Workflow(update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': 'v2.0',
'frequency': 1,
})
wf.run(fake)
# Check won't have completed yet
self.assertFalse(wf.update_available)
# wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
time.sleep(1)
# There *is* a newer version in the repo
self.assertTrue(wf.update_available)
# Mock out subprocess and check the correct command is run
c = WorkflowMock()
with c:
self.assertTrue(wf.start_update())
# wf.logger.debug('start_update : {}'.format(c.cmd))
self.assertEquals(c.cmd[0], '/usr/bin/python')
self.assertEquals(c.cmd[2], '__workflow_update_install')
# Grab the updated release data, then reset the cache
update_info = wf.cached_data('__workflow_update_status')
wf.reset()
# Initialise with latest available release
wf = Workflow(update_settings={
'github_slug': 'deanishe/alfred-workflow-dummy',
'version': update_info['version'],
})
wf.run(fake)
# Wait for background update check
self.assertTrue(is_running('__workflow_update_check'))
while is_running('__workflow_update_check'):
time.sleep(0.05)
# Remote version is same as the one we passed to Workflow
self.assertFalse(wf.update_available)
self.assertFalse(wf.start_update())
def is_dark():
rgb = [int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')]
return (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2] ) / 255 < 0.5
if __name__ == '__main__':
from brew_actions import ACTIONS
if WF.update_available:
WF.add_item(
"An update is available!",
autocomplete='workflow:update',
valid=False,
icon=get_icon("cloud-download")
)
if WF.cached_data('brew_not_installed', brew_not_installed, max_age=0):
WF.add_item(
'Brew does not seem to be installed!',
'Hit enter to see what you need to do...',
arg='open http://brew.sh/#install && exit',
valid=True
)
WF.add_item(
'I trust this workflow',
'Hit enter to install brew...',
arg='ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"',
valid=True
)
# delete cached file
WF.cache_data('brew_not_installed', None)
else:
def is_dark():
rgb = [int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')]
return (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255 < 0.5
if __name__ == '__main__':
from brew_actions import ACTIONS
if WF.update_available:
WF.add_item("An update is available!",
autocomplete='workflow:update',
valid=False,
icon=get_icon("cloud-download"))
if WF.cached_data('brew_not_installed', brew_not_installed, max_age=0):
WF.add_item('Brew does not seem to be installed!',
'Hit enter to see what you need to do...',
arg='open http://brew.sh/#install && exit',
valid=True)
WF.add_item(
'I trust this workflow',
'Hit enter to install brew...',
arg=
'ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"',
valid=True)
# delete cached file
WF.cache_data('brew_not_installed', None)
else:
# extract query
query = WF.args[0] if len(WF.args) else None
class UpdateTests(unittest.TestCase):
def setUp(self):
self.wf = Workflow()
def test_download_workflow(self):
"""Update: Download workflow update"""
with self.assertRaises(ValueError):
update.download_workflow(URL_BAD)
local_file = update.download_workflow(URL_DL)
self.assertTrue(local_file.endswith('.alfredworkflow'))
self.assertTrue(os.path.isfile(local_file))
def test_valid_api_url(self):
"""Update: API URL for valid slug"""
url = update.build_api_url(TEST_REPO_SLUG)
self.assertEquals(url, RELEASES_URL)
def test_invalid_api_url(self):
"""Update: API URL for invalid slug"""
with self.assertRaises(ValueError):
update.build_api_url('fniephausalfred-workflow')
def test_empty_repo(self):
"""Update: no releases"""
with self.assertRaises(ValueError):
update.check_update(EMPTY_REPO_SLUG, '1.0')
self.assertEquals(len(update.get_valid_releases(EMPTY_REPO_SLUG)), 0)
def test_valid_releases(self):
"""Update: valid releases"""
releases = update.get_valid_releases(TEST_REPO_SLUG)
# Right number of valid releases
self.assertEquals(len(releases), 3)
# Invalid releases are not in list
versions = [d['version'] for d in releases]
for v in RELEASES_INVALID:
self.assertFalse(v in versions)
# Correct latest release
self.assertEquals(update.Version(releases[0]['version']),
update.Version(RELEASE_LATEST))
def test_version_formats(self):
"""Update: version formats"""
# Up-to-date versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, '6.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v6.0'))
# Old versions
self.assertTrue(update.check_update(TEST_REPO_SLUG, 'v5.0'))
self.assertTrue(update.check_update(TEST_REPO_SLUG, '5.0'))
# Unknown versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v8.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, '8.0'))
def test_check_update(self):
"""Update: Check update"""
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
update_info = self.wf.cached_data('__workflow_update_status')
self.assertFalse(update.check_update(TEST_REPO_SLUG,
update_info['version']))
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertIsNone(wf.cached_data('__workflow_update_status'))
self.assertFalse(update.install_update(TEST_REPO_SLUG,
RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(update.install_update(TEST_REPO_SLUG,
RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(wf.cached_data(
'__workflow_update_status')['available'])
def test_no_auto_update(self):
"""Update: no update check"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
wf = Workflow()
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf.args
self.assertFalse(wf.settings.get('__workflow_autoupdate'))
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
c = WorkflowMock()
with c:
wf = Workflow(update_settings={'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT})
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
for item in sorted(get_list.values(), key=lambda x: int(x['time_added']), reverse=True):
item_list.append(item)
return item_list
except AuthException:
return 'error1'
wf.delete_password('pocket_access_token')
wf.logger.error(
'There was a problem receiving your Pocket list. The workflow has been deauthenticated automatically. Please try again!')
except Exception:
return 'error2'
wf.logger.error(
'Could not contact getpocket.com. Please check your Internet connection and try again!')
return None
if __name__ == '__main__':
wf = Workflow()
try:
access_token = wf.get_password('pocket_access_token')
def wrapper():
return get_list(wf, access_token)
wf.cached_data('pocket_list', data_func=wrapper, max_age=1)
except PasswordNotFound:
wf.logger.error('Password not found!')
def is_dark():
return min([int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')]) < 128
if __name__ == '__main__':
from cask_actions import ACTIONS
if WF.update_available:
WF.add_item(
"An update is available!",
autocomplete='workflow:update',
valid=False,
icon=get_icon("cloud-download")
)
if WF.cached_data('cask_not_installed', cask_not_installed, max_age=0):
WF.add_item('Cask does not seem to be installed!',
'Hit enter to see what you need to do...', arg='open http://caskroom.io/ && exit', valid=True)
WF.add_item('I trust this workflow',
'Hit enter to install cask...', arg='brew install caskroom/cask/brew-cask', valid=True)
# delete cached file
WF.cache_data('cask_not_installed', None)
else:
# extract query
query = WF.args[0] if len(WF.args) else None
if query and query.startswith('install'):
for formula in get_all_casks(query):
WF.add_item(
formula, "Install cask",
arg='brew cask install %s' % formula,
for c in iglob(notebook + "/*.qvnote/content.json"):
meta = load_json(c.replace("content.json", "meta.json"))
content = load_json(c)
tagset = meta["tags"]
full_content = ' '.join([x["data"] for x in content["cells"]])
snippets = [x for x in content["cells"] if x["type"] == "code"]
# Store Notes
n = Note.create(uuid = meta["uuid"],
title = meta["title"],
notebook = nb_name,
last_modified = datetime.datetime.fromtimestamp(meta["updated_at"]))
NoteIndex.insert({
NoteIndex.docid: n.id,
NoteIndex.uuid: n.uuid,
NoteIndex.title: n.title,
NoteIndex.content: full_content}).execute()
# Store tags
for tag in tagset:
Tags.create(note = n, tag = tag)
#for snip in snippets:
# s = Snippets.create(note = n.id, language = snip["language"])
# SnippetsIndex.insert({
# SnippetsIndex.docid: s.id,
# SnippetsIndex.uuid: n.uuid,
# SnippetsIndex.title: n.title,
# SnippetsIndex.content: snip["data"]
# }).execute()
def item():
return 1
wf.cached_data('update_db', item, max_age=10)
class RatesCurrencyTest(unittest.TestCase):
def setUp(self):
self.wf = Workflow()
self.wf.clear_settings()
self.wf.clear_data()
self.wf.clear_cache()
rates.log = self.wf.logger
def tearDown(self):
pass
def testLoadCurrencyInfo(self):
currency_info = rates.get_currencies()
# Checks if all itens have all info that is used by the script
for currency, info in currency_info.iteritems():
self.assertIn('Id', info, 'No ID for currency {}'.format(info))
self.assertTrue(info['Id'], 'None ID specified for currency {}'.format(info))
self.assertIn('Name', info, 'No Name for currency {}'.format(info))
self.assertTrue(info['Name'], 'No Name for currency {}'.format(info))
self.assertIn('Code', info, 'No Code for currency {}'.format(info))
self.assertTrue(info['Code'], 'No Code for currency {}'.format(info))
self.assertIn('Simbol', info, 'No Simbol for currency {}'.format(info))
self.assertTrue(info['Simbol'], 'No Simbol for currency {}'.format(info))
self.assertIn('Country', info, 'No Country for currency {}'.format(info))
self.assertTrue(info['Country'], 'No Country for currency {}'.format(info))
self.assertIn('Flag', info, 'No Flag for currency {}'.format(info))
def test_is_float(self):
tests = [(1, True),
('asd', False),
(1.5, True),
('1', True),
('1', True)]
for test in tests:
self.assertEqual(rates.is_float(test[0]), test[1])
def test_validate_currencies(self):
currencies = rates.get_currencies()
self.assertTrue(rates.validate_currencies([], 'BRL', 'USD', currencies, self.wf))
self.assertFalse(rates.validate_currencies([], 'BRL', 'USDD', currencies, self.wf))
self.assertFalse(rates.validate_currencies([], 'BRLL', 'USD', currencies, self.wf))
def test_clear_caches(self):
self.wf.cache_data('test_cache', 'testing cache')
self.wf.store_data('test_store', 'testing store')
with patch.object(sys, 'argv', 'program --clear'.split()):
rates.main(self.wf)
self.assertEqual(len(self.wf._items), 1)
self.assertEqual(self.wf._items[0].title, 'Caches cleared!')
self.assertIsNone(self.wf.stored_data('test_store'))
self.assertIsNone(self.wf.cached_data('test_cache'))
def test_evaluate_math(self):
tests = [
(['100*3', '100'], ['300', '100']),
(['135.3*2', '234.5-5'], ['270.6', '229.5']),
(['123/2', '61.5*50'], ['61.5', '3075.0']),
(['123.5*2.5'], ['308.75']),
# (['123', '/2', '61.5*50'], ['61.5', '3075.0']),
# (['123', '/', '2', '61.5*50'], ['61.5', '3075.0']),
# (['123', '/2', '/', '2', '61.5*50'], ['30.75', '3075.0']),
# (['123', '/2', '/', '2', '61.5*50', '/3', '*2'], ['30.75', '2050.0'])
# (['123*', '2'], ['246'])
# (['100*2', 'usd', 'brl'], ['200', 'usd', 'brl'])
]
for t in tests:
result = rates.evaluate_math(t[0])
self.assertEqual(result, t[1])
def test_fmt_number(self):
tests = [
('100.00', '.', '100.00'),
('100.00', ',', '100,00'),
('1.000,00', '.', '1,000.00'),
('100', None, '100')
]
for t in tests:
result = rates.fmt_number(t[0], t[1])
self.assertEqual(result, t[2])
from urllib2 import URLError
from pocket import Pocket, AuthException, PocketException
from workflow import Workflow, PasswordNotFound
import config
LINK_LIMIT = 2000
if __name__ == '__main__':
wf = Workflow()
error = None
try:
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
item_list = wf.cached_data('pocket_list', max_age=0)
# only use delta syncing if list is not empty
if item_list and len(item_list) > 0:
since = wf.cached_data('pocket_since', max_age=0)
else:
since = 0
if not type(item_list) is list:
item_list = []
state = 'all' if len(item_list) > 0 else None
next_since = 0
offset = 0
while True:
class UpdateTests(unittest.TestCase):
def setUp(self):
self.wf = Workflow()
def test_download_workflow(self):
"""Update: Download workflow update"""
with self.assertRaises(ValueError):
update.download_workflow(URL_BAD)
local_file = update.download_workflow(URL_DL)
self.assertTrue(local_file.endswith('.alfredworkflow'))
self.assertTrue(os.path.isfile(local_file))
def test_valid_api_url(self):
"""Update: API URL for valid slug"""
url = update.build_api_url(TEST_REPO_SLUG)
self.assertEquals(url, RELEASES_URL)
def test_invalid_api_url(self):
"""Update: API URL for invalid slug"""
with self.assertRaises(ValueError):
update.build_api_url('fniephausalfred-workflow')
def test_empty_repo(self):
"""Update: no releases"""
with self.assertRaises(ValueError):
update.check_update(EMPTY_REPO_SLUG, '1.0')
self.assertEquals(len(update.get_valid_releases(EMPTY_REPO_SLUG)), 0)
def test_valid_releases(self):
"""Update: valid releases"""
releases = update.get_valid_releases(TEST_REPO_SLUG)
# Right number of valid releases
self.assertEquals(len(releases), 3)
# Invalid releases are not in list
versions = [d['version'] for d in releases]
for v in RELEASES_INVALID:
self.assertFalse(v in versions)
# Correct latest release
self.assertEquals(update.Version(releases[0]['version']),
update.Version(RELEASE_LATEST))
def test_version_formats(self):
"""Update: version formats"""
# Up-to-date versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, '6.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v6.0'))
# Old versions
self.assertTrue(update.check_update(TEST_REPO_SLUG, 'v5.0'))
self.assertTrue(update.check_update(TEST_REPO_SLUG, '5.0'))
# Unknown versions
self.assertFalse(update.check_update(TEST_REPO_SLUG, 'v8.0'))
self.assertFalse(update.check_update(TEST_REPO_SLUG, '8.0'))
def test_check_update(self):
"""Update: Check update"""
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
update_info = self.wf.cached_data('__workflow_update_status')
self.assertFalse(
update.check_update(TEST_REPO_SLUG, update_info['version']))
def test_install_update(self):
"""Update: installs update"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
# Verify that there's no update available
self.assertIsNone(wf.cached_data('__workflow_update_status'))
self.assertFalse(update.install_update(TEST_REPO_SLUG, RELEASE_LATEST))
# Get new update data
self.assertTrue(update.check_update(TEST_REPO_SLUG, RELEASE_CURRENT))
# Verify new workflow is downloaded and installed
c = WorkflowMock()
with c:
self.assertTrue(
update.install_update(TEST_REPO_SLUG, RELEASE_CURRENT))
self.assertEquals(c.cmd[0], 'open')
self.assertTrue(c.cmd[1].endswith('.alfredworkflow'))
self.assertFalse(
wf.cached_data('__workflow_update_status')['available'])
def test_no_auto_update(self):
"""Update: no update check"""
# Make sure there's no cached update data
wf = Workflow()
wf.reset()
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
wf = Workflow()
c = WorkflowMock(['script', 'workflow:noautoupdate'])
with c:
wf.args
self.assertFalse(wf.settings.get('__workflow_autoupdate'))
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
c = WorkflowMock()
with c:
wf = Workflow(update_settings={
'github_slug': TEST_REPO_SLUG,
'version': RELEASE_CURRENT
})
self.assertIsNone(self.wf.cached_data('__workflow_update_status'))
