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 workflow():
    global _workflow, _update_settings

    if _workflow is None:
        version = '__VERSION__'

        _workflow = Workflow(
            capture_args=False,
            update_settings={
                'github_slug': 'idpaterson/alfred-wunderlist-workflow',
                'version': version,
                # Check for updates daily
                # TODO: check less frequently as the workflow becomes more
                # stable
                'frequency': 1,
                # Always download pre-release updates if a prerelease is
                # currently installed
                'prerelease': '-' in version
            }
        )

        # Avoid default logger output configuration
        _workflow.logger = logging.getLogger('workflow')

    return _workflow

def get_path(_type):
    """Read paths.json file from non-volatile storage"""
    wf = Workflow()
    with open(wf.datafile("paths.json"), "r") as f:
        _paths = json.load(f)
        f.close()
    return to_unicode(_paths[_type])

class TestDownload(unittest.TestCase):
    def setUp(self):
        self.wf = Workflow()
        self.wf.reset()
        download.log = self.wf.logger

    def tearDown(self):
        self.wf.reset()

    def test_download(self):
        download_link = 'http://filepi.com/i/RSpHA1T'
        ebook_id = '1529159300'
        ebook_title = 'Expert Oracle and Java Security'

        args = 'program --download-from-itebooks {} {} {}'.format(download_link, ebook_id, ebook_title).split()

        with patch.object(sys, 'argv', args):
            ret = download.main(self.wf)

        download_folder = os.path.expanduser(itebooks.default_download_folder)

        file_name = 'Expert Oracle and Java Security.pdf'

        file_path = os.path.join(download_folder, file_name)

        self.assertEqual(ret, 0)
        self.assertTrue(os.path.exists(file_path))

        # Removes the downloaded file

        try:
            os.remove(file_path)
        except OSError:
            pass

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_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 slack_list(keys):
    wf = Workflow()
    slack_search = []

    for key in keys:
        api_key = str(key)
        slack_auth = web.get('https://slack.com/api/auth.test?token=' + api_key + '&pretty=1').json()
        if slack_auth['ok'] is False:
            wf.add_item(title='Authentication failed. Check your API key',
                        valid=False)
            wf.send_feedback()
            break
        else:
            slack_channels = web.get('https://slack.com/api/channels.list?token=' + api_key +
                                     '&exclude_archived=1&pretty=1').json()
            slack_users = web.get('https://slack.com/api/users.list?token=' + api_key + '&pretty=1').json()
            slack_groups = web.get('https://slack.com/api/groups.list?token=' + api_key + '&pretty=1').json()
            for channels in slack_channels['channels']:
                slack_search.append({'name': channels['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': channels['id'], 'type': 'channel', 'api_key': api_key})
            for users in slack_users['members']:
                slack_search.append({'name': users['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': users['id'], 'type': 'user', 'api_key': api_key})
                slack_search.append({'name': users['profile']['real_name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': users['id'], 'type': 'user', 'api_key': api_key})
            for groups in slack_groups['groups']:
                if 'name' in groups:
                    slack_search.append({'name': groups['name'], 'team': slack_auth['team'],'team_id': slack_auth['team_id'], 'id': groups['id'], 'type': 'group', 'api_key': api_key})
    return slack_search

    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_open_term(infopl):
    """Magic: open Terminal"""
    with WorkflowMock(['script', 'workflow:openterm']) as c:
        wf = Workflow()
        # Process magic arguments
        wf.args
        assert c.cmd == ['open', '-a', 'Terminal', wf.workflowdir]
        wf.reset()

def test_workflowdir(infopl):
    """Magic: open workflowdir"""
    with WorkflowMock(['script', 'workflow:openworkflow']) as c:
        wf = Workflow()
        # Process magic arguments
        wf.args
        assert c.cmd == ['open', wf.workflowdir]
        wf.reset()

    def test_get_year_day_of_year(self):
        w = Workflow('test', 7)

        date = datetime.date(1989, 12, 9)
        self.assertEqual('1989-343', w._get_year_day_of_year(date))

        date = datetime.date(1989, 2, 7)
        self.assertEqual('1989-038', w._get_year_day_of_year(date))

def test_openhelp_no_url(infopl):
    """Magic: no help URL"""
    with WorkflowMock(['script', 'workflow:help']) as c:
        wf = Workflow()
        # Process magic arguments
        wf.args
        assert not c.cmd
        wf.reset()

def test_openlog(infopl):
    """Magic: open logfile"""
    with WorkflowMock(['script', 'workflow:openlog']) as c:
        wf = Workflow()
        # Process magic arguments
        wf.args
        assert c.cmd == ['open', wf.logfile]
        wf.reset()

def get_formats():
    """Return combination of saved custom formats and defaults for locale"""

    wf = Workflow()

    if not 'date_formats' in wf.settings:
        wf.settings['date_formats'] = get_default_formats()

    return wf.settings.get('date_formats')

    def test_get_next_period_cut_at_month_end(self):
        w = Workflow('test', 10)

        date = datetime.date(2001, 9, 22)
        next_period = w._get_next_period(date)
        self.assertEqual(Period((2001, 9, 23), (2001, 9, 30)), next_period)

        next_period = w._get_next_period(next_period.get_end_date())
        self.assertEqual(Period((2001, 10, 1), (2001, 10, 10)), next_period)

 def test_nmax(self):
     print 'test_nmax'
     result = False
     wf = Workflow()
     wf.add_workflow(self.tutorial_dir_1, None)
     
     print get_nmax(wf, [], [], datetime(2000,1,1)) 
     result = True
     self.assertTrue(result)

def test_openhelp(infopl):
    """Magic: open help URL"""
    url = 'http://www.deanishe.net/alfred-workflow/'
    with WorkflowMock(['script', 'workflow:help']) as c:
        wf = Workflow(help_url=url)
        # Process magic arguments
        wf.args
        assert c.cmd == ['open', url]
        wf.reset()

def test_list_magic(infopl):
    """Magic: list magic"""
    # TODO: Verify output somehow
    with WorkflowMock(['script', 'workflow:magic']) as c:
        wf = Workflow()
        # Process magic arguments
        wf.args
        assert not c.cmd
        wf.reset()

    def test_get_next_period_overlap_year(self):
        w = Workflow('test', 7)

        date = datetime.date(2001, 12, 26)
        next_period = w._get_next_period(date)
        self.assertEqual(Period((2001, 12, 27), (2001, 12, 31)), next_period)

        next_period = w._get_next_period(next_period.get_end_date())
        self.assertEqual(Period((2002, 1, 1), (2002, 1, 7)), next_period)

 def test_workflow(self):
     print 'test_workflow'
     result = False
     
     w = Workflow()
     w.add_workflow(self.tutorial_dir_1, None)
     for j in w.jobs:
         print j.id
     
     print [j.rank for j in w.ranked_jobs]