def test_last_version_explicit_version(self):
     """Workflow: last_version explicit version"""
     vstr = '1.9.6'
     wf = Workflow()
     self.assertTrue(wf.set_last_version(vstr))
     self.assertEqual(wf.last_version_run, Version(vstr))
     wf.reset()

def test_first_run_with_version(alfred4, infopl):
    """Workflow: first_run"""
    vstr = '1.9.7'
    with env(alfred_workflow_version=vstr):
        wf = Workflow()
        assert wf.first_run is True
        wf.reset()

def test_last_version_explicit_version(alfred4, infopl):
    """Workflow: last_version explicit version"""
    vstr = '1.9.6'
    wf = Workflow()
    assert wf.set_last_version(vstr) is True
    assert wf.last_version_run == Version(vstr)
    wf.reset()

 def test_first_run_with_version(self):
     """Workflow: first_run"""
     vstr = '1.9.7'
     with VersionFile(vstr):
         with InfoPlist():
             wf = Workflow()
             self.assertTrue(wf.first_run)
         wf.reset()

def test_last_version_auto_version(alfred4, infopl):
    """Workflow: last_version auto version"""
    vstr = '1.9.7'
    with env(alfred_workflow_version=vstr):
        wf = Workflow()
        assert wf.set_last_version() is True
        assert wf.last_version_run == Version(vstr)
        wf.reset()

def test_first_run_no_version(alfred4, infopl2):
    """Workflow: first_run fails on no version"""
    with env(alfred_workflow_version=None):
        wf = Workflow()
        try:
            with pytest.raises(ValueError):
                wf.first_run
        finally:
            wf.reset()

 def test_last_version_auto_version(self):
     """Workflow: last_version auto version"""
     vstr = '1.9.7'
     with VersionFile(vstr):
         with InfoPlist():
             wf = Workflow()
             self.assertTrue(wf.set_last_version())
             self.assertEqual(wf.last_version_run, Version(vstr))
             wf.reset()

def test_additional_libs(alfred4, infopl):
    """Additional libraries"""
    wf = Workflow(libraries=LIBS)
    for path in LIBS:
        assert path in sys.path

    assert sys.path[0:len(LIBS)] == LIBS
    import youcanimportme
    youcanimportme.noop()
    wf.reset()

def test_first_run_with_previous_run(alfred4, infopl):
    """Workflow: first_run with previous run"""
    vstr = '1.9.7'
    last_vstr = '1.9.6'
    with env(alfred_workflow_version=vstr):
        wf = Workflow()
        wf.set_last_version(last_vstr)
        assert wf.first_run is True
        assert wf.last_version_run == Version(last_vstr)
        wf.reset()

def test_run_fails(infopl):
    """Run fails"""
    wf = Workflow()

    def cb(wf2):
        assert wf2 is wf
        raise ValueError('Have an error')

    wf.help_url = 'http://www.deanishe.net/alfred-workflow/'
    ret = wf.run(cb)
    assert ret == 1

    # read name from info.plist
    with env(alfred_workflow_name=None):
        wf = Workflow()
        wf.name
        ret = wf.run(cb)
        assert ret == 1

        # named after bundleid
        wf = Workflow()
        wf.bundleid
        ret = wf.run(cb)
        assert ret == 1

    wf.reset()

 def test_first_run_with_previous_run(self):
     """Workflow: first_run with previous run"""
     vstr = '1.9.7'
     last_vstr = '1.9.6'
     with VersionFile(vstr):
         with InfoPlist():
             wf = Workflow()
             wf.set_last_version(last_vstr)
             self.assertTrue(wf.first_run)
             self.assertEqual(wf.last_version_run, Version(last_vstr))
         wf.reset()

 def test_delete_cache(self):
     """Magic: delete cache"""
     c = WorkflowMock(['script', 'workflow:delcache'])
     wf = Workflow()
     testpath = wf.cachefile('file.test')
     with open(testpath, 'wb') as file_obj:
         file_obj.write('test!')
     with c:
         self.assertTrue(os.path.exists(testpath))
         # Process magic arguments
         wf.args
         self.assertFalse(os.path.exists(testpath))

 def test_delete_settings(self):
     """Magic: delete settings"""
     c = WorkflowMock(['script', 'workflow:delsettings'])
     wf = Workflow()
     wf.settings['key'] = 'value'
     filepath = wf.datafile('settings.json')
     with c:
         self.assertTrue(os.path.exists(filepath))
         wf2 = Workflow()
         self.assertEquals(wf2.settings.get('key'), 'value')
         # Process magic arguments
         wf.args
         self.assertFalse(os.path.exists(filepath))
         wf3 = Workflow()
         self.assertFalse('key' in wf3.settings)

    def setUp(self):
        self.libs = [os.path.join(os.path.dirname(__file__), 'lib')]
        self.wf = Workflow(libraries=self.libs)
        self.account = 'this-is-my-test-account'
        self.password = 'this-is-my-safe-password'
        self.password2 = 'this-is-my-other-safe-password'
        self.search_items = [
            ('Test Item One', MATCH_STARTSWITH),
            ('test item two', MATCH_STARTSWITH),
            ('TwoExtraSpecialTests', MATCH_CAPITALS),
            ('this-is-a-test', MATCH_ATOM),
            ('the extra special trials', MATCH_INITIALS_STARTSWITH),
            ('not the extra special trials', MATCH_INITIALS_CONTAIN),
            ('intestinal fortitude', MATCH_SUBSTRING),
            ('the splits', MATCH_ALLCHARS),
            ('nomatch', 0),
        ]

        self.search_items_diacritics = [
            # search key, query
            ('Änderungen vorbehalten', 'av'),
            ('Änderungen', 'anderungen'),
            ('überwiegend bewolkt', 'ub'),
            ('überwiegend', 'uberwiegend'),
            ('Öffnungszeiten an Feiertagen', 'offnungszeiten'),
            ('Öffnungszeiten an Feiertagen', 'oaf'),
            ('Fußpilz', 'fuss'),
            ('salé', 'sale')
        ]

    def setUp(self):
        self.libs = [os.path.join(os.path.dirname(__file__), "lib")]
        self.wf = Workflow(libraries=self.libs)
        self.account = "this-is-my-test-account"
        self.password = "this-is-my-safe-password"
        self.password2 = "this-is-my-other-safe-password"
        self.search_items = [
            ("Test Item One", MATCH_STARTSWITH),
            ("test item two", MATCH_STARTSWITH),
            ("TwoExtraSpecialTests", MATCH_CAPITALS),
            ("this-is-a-test", MATCH_ATOM),
            ("the extra special trials", MATCH_INITIALS_STARTSWITH),
            ("not the extra special trials", MATCH_INITIALS_CONTAIN),
            ("intestinal fortitude", MATCH_SUBSTRING),
            ("the splits", MATCH_ALLCHARS),
            ("nomatch", 0),
        ]

        self.search_items_diacritics = [
            # search key, query
            ("Änderungen vorbehalten", "av"),
            ("Änderungen", "anderungen"),
            ("überwiegend bewolkt", "ub"),
            ("überwiegend", "uberwiegend"),
            ("Öffnungszeiten an Feiertagen", "offnungszeiten"),
            ("Öffnungszeiten an Feiertagen", "oaf"),
            ("Fußpilz", "fuss"),
            ("salé", "sale"),
        ]

def test_last_version_on(alfred4, infopl):
    """Workflow: last_version_run not empty"""
    vstr = '1.9.7'

    with env(alfred_workflow_version=vstr):
        wf = Workflow()
        wf.set_last_version(vstr)
        assert Version(vstr) == wf.last_version_run
        wf.reset()

    # Set automatically
    with env(alfred_workflow_version=vstr):
        wf = Workflow()
        wf.set_last_version()
        assert Version(vstr) == wf.last_version_run
        wf.reset()

    def test_last_version_on(self):
        """Workflow: last_version_run not empty"""
        vstr = '1.9.7'

        with InfoPlist():
            with VersionFile(vstr):
                wf = Workflow()
                wf.set_last_version(vstr)
                self.assertEqual(Version(vstr), wf.last_version_run)
                wf.reset()
            # Set automatically
            with VersionFile(vstr):
                wf = Workflow()
                wf.set_last_version()
                self.assertEqual(Version(vstr), wf.last_version_run)
                wf.reset()

    def test_magic_args(self):
        """Magic args"""
        # cache original sys.argv
        oargs = sys.argv[:]

        # delsettings
        sys.argv = [oargs[0]] + [b'workflow:delsettings']
        try:
            wf = Workflow(default_settings={'arg1': 'value1'})
            self.assertEqual(wf.settings['arg1'], 'value1')
            self.assertTrue(os.path.exists(wf.settings_path))
            with self.assertRaises(SystemExit):
                wf.args
            self.assertFalse(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)
            self.assertTrue(os.path.exists(wf.cachefile('test.cpickle')))
            with self.assertRaises(SystemExit):
                wf.args
            self.assertFalse(os.path.exists(wf.cachefile('test.cpickle')))
        finally:
            sys.argv = oargs[:]

    def setUp(self):
        self.libs = [os.path.join(os.path.dirname(__file__), b'lib')]
        self.account = 'this-is-my-test-account'
        self.password = 'this-is-my-safe-password'
        self.password2 = 'this-is-my-other-safe-password'
        self.search_items = [
            ('Test Item One', MATCH_STARTSWITH),
            ('test item two', MATCH_STARTSWITH),
            ('TwoExtraSpecialTests', MATCH_CAPITALS),
            ('this-is-a-test', MATCH_ATOM),
            ('the extra special trials', MATCH_INITIALS_STARTSWITH),
            ('not the extra special trials', MATCH_INITIALS_CONTAIN),
            ('intestinal fortitude', MATCH_SUBSTRING),
            ('the splits', MATCH_ALLCHARS),
            ('nomatch', 0),
        ]

        self.search_items_diacritics = [
            # search key, query
            ('Änderungen vorbehalten', 'av'),
            ('Änderungen', 'anderungen'),
            ('überwiegend bewolkt', 'ub'),
            ('überwiegend', 'uberwiegend'),
            ('Öffnungszeiten an Feiertagen', 'offnungszeiten'),
            ('Öffnungszeiten an Feiertagen', 'oaf'),
            ('Fußpilz', 'fuss'),
            ('salé', 'sale')
        ]

        self.env_data = {
            'alfred_preferences':
            os.path.expanduser('~/Dropbox/Alfred/Alfred.alfredpreferences'),
            'alfred_preferences_localhash':
            b'adbd4f66bc3ae8493832af61a41ee609b20d8705',
            'alfred_theme': b'alfred.theme.yosemite',
            'alfred_theme_background': b'rgba(255,255,255,0.98)',
            'alfred_theme_subtext': b'3',
            'alfred_version': b'2.4',
            'alfred_version_build': b'277',
            'alfred_workflow_bundleid': str(BUNDLE_ID),
            'alfred_workflow_cache':
            os.path.expanduser(b'~/Library/Caches/com.runningwithcrayons.'
                               b'Alfred-2/Workflow Data/{}'.format(BUNDLE_ID)),
            'alfred_workflow_data':
            os.path.expanduser(b'~/Library/Application Support/Alfred 2/'
                               b'Workflow Data/{}'.format(BUNDLE_ID)),
            'alfred_workflow_name': b'Alfred-Workflow Test',
            'alfred_workflow_uid':
            b'user.workflow.B0AC54EC-601C-479A-9428-01F9FD732959',
        }

        self._setup_env()

        self.wf = Workflow(libraries=self.libs)

 def test_update(self):
     """Workflow updating methods"""
     self.assertFalse(self.wf.update_available)
     self.wf = Workflow(update_info={
         'github_slug': 'fniephaus/alfred-pocket',
         'version': 'v0.0',
         'frequency': 1,
     })
     # wait for background update check
     time.sleep(2)
     self.assertTrue(self.wf.update_available)
     self.assertTrue(self.wf.start_update())
     update_info = self.wf.cached_data('__workflow_update_available')
     self.wf = Workflow(update_info={
         'github_slug': 'fniephaus/alfred-pocket',
         'version': update_info['version'],
     })
     # wait for background update check
     time.sleep(2)
     self.assertFalse(self.wf.update_available)
     self.assertFalse(self.wf.start_update())