class TestCassandraStore(Store, Spawn, unittest.TestCase):

        cmd = ['cassandra', '-f']

        @classmethod
        def setUpClass(cls):
            super(TestCassandraStore, cls).setUpClass()
            import time
            time.sleep(5.0)

        def setUp(self):
            from shove import Shove
            from pycassa.system_manager import SystemManager  # @UnresolvedImport @IgnorePep8
            system_manager = SystemManager('localhost:9160')
            try:
                system_manager.create_column_family('Murk', 'shove')
            except:
                pass
            self.store = Shove('cassandra://localhost:9160/Murk/shove')

        def tearDown(self):
            if self.store._store is not None:
                self.store.clear()
                self.store.close()
            from pycassa.system_manager import SystemManager  # @UnresolvedImport @IgnorePep8
            system_manager = SystemManager('localhost:9160')
            system_manager.drop_column_family('Murk', 'shove')

        @classmethod
        def tearDownClass(cls):
            from fabric.api import local
            local('killall java')

    def test_execute_invalid_command(self):
        """If the given command could not be found for the given project, return an error tuple."""
        shove = Shove({"myproject": path("test_project")}, Mock())
        order = Order(project="myproject", command="foo", log_key=5, log_queue="asdf")

        procfile_path = path("test_project", "bin", "commands.procfile")
        eq_(shove.execute(order), (1, "No command `foo` found in {0}".format(procfile_path)))

 def __init__(self, port, link_db_uri, user_db_uri, use_auth=True):
     self.port = port
     self.link_db = Shove(link_db_uri)
     self.user_db = Shove(user_db_uri)
     self.use_auth = use_auth
     if not self.use_auth and 'null' not in self.user_db:
         self.user_db['null'] = {'token': '', 'username':'null', 'links': []}

    def test_execute_invalid_command(self):
        """If the given command could not be found for the given project, return an error tuple."""
        shove = Shove({'myproject': path('test_project')})
        order = Order(project='myproject', command='foo', log_key=5, log_queue='asdf')

        procfile_path = path('test_project', 'bin', 'commands.procfile')
        eq_(shove.execute(order), (1, 'No command `foo` found in {0}'.format(procfile_path)))

 def test__cmp__(self):
     tstore = Shove()
     self.store['max'] = 3
     tstore['max'] = 3
     self.store.sync()
     tstore.sync()
     self.assertEqual(self.store, tstore)

    def getRSSFeed(self, url, post_data=None):
        # create provider storaqe cache
        storage = Shove('sqlite:///' + ek.ek(os.path.join, sickbeard.CACHE_DIR, self.provider.name) + '.db')
        fc = cache.Cache(storage)

        parsed = list(urlparse.urlparse(url))
        parsed[2] = re.sub("/{2,}", "/", parsed[2])  # replace two or more / with one

        if post_data:
            url = url + 'api?' + urllib.urlencode(post_data)

        f = fc.fetch(url)

        if not f:
            logger.log(u"Error loading " + self.providerID + " URL: " + url, logger.ERROR)
            return None
        elif 'error' in f.feed:
            logger.log(u"Newznab ERROR:[%s] CODE:[%s]" % (f.feed['error']['description'], f.feed['error']['code']),
                       logger.DEBUG)
            return None
        elif not f.entries:
            logger.log(u"No items found on " + self.providerID + " using URL: " + url, logger.WARNING)
            return None

        storage.close()

        return f

 def test__cmp__(self):
     from shove import Shove
     tstore = Shove()
     self.store['max'] = 3
     tstore['max'] = 3
     self.store.sync()
     tstore.sync()
     self.assertEqual(self.store, tstore)

 def test_parse_order_valid(self):
     """If the given order is valid, return an Order namedtuple with the correct values."""
     shove = Shove({}, Mock())
     order = shove.parse_order('{"project": "asdf", "command": "qwer", "log_key": 77, ' '"log_queue": "zxcv"}')
     eq_(order.project, "asdf")
     eq_(order.command, "qwer")
     eq_(order.log_key, 77)
     eq_(order.log_queue, "zxcv")

 def test_parse_procfile(self):
     shove = Shove({})
     commands = shove.parse_procfile(path('test_procfile.procfile'))
     eq_(commands, {
         'cmd': ['test'],
         'valid_underscore': ['homer'],
         'valid03': ['foo', 'bar' ,'--baz']
     })

    def test_process_order_invalid(self):
        """If parse_order returns None, do not execute the order."""
        shove = Shove({})
        shove.parse_order = Mock(return_value=None)
        shove.execute = Mock()

        eq_(shove.process_order('{"project": "asdf"}'), None)
        ok_(not shove.execute.called)

class _ShoveWrapper(object):
    def __init__(self, loc):
        self._loc = loc
        self._shove = Shove(self._loc)

    def __enter__(self):
        return self._shove

    def __exit__(self, type, value, traceback):
        self._shove.close()

class TestFTPStore(Store, unittest.TestCase):

    initstring = 'ftp://127.0.0.1/'

    def setUp(self):
        from shove import Shove
        self.store = Shove(self.initstring, compress=True)

    def tearDown(self):
        self.store.clear()
        self.store.close()

 def primary_file_name(self):
     """The file name for the 'primary' file in the bucket. It is this file from which data is loaded. Other files
     within the bucket should be auxiliary to this file. (E.g. they should contain projection information.)
     """
     shove = Shove(self._shove_url)
     try:
         return shove['primary_file_name']
     except KeyError:
         return None
     finally:
         shove.close()

def load_facts(config):
    import requests
    from bs4 import BeautifulSoup
    db = Shove(config['dburi'])
    db['facts'] = []
    url1 = 'http://www.cats.alpha.pl/facts.htm'
    raw = requests.get(url1).text
    soup = BeautifulSoup(raw).findAll('ul')[1]
    for string in soup.stripped_strings:
        if string:
            db['facts'].append(string)
    db.sync()

    def test_process_order_valid(self):
        """If parse_order returns a valid order, execute it and send logs back to Captain."""
        shove = Shove({}, Mock())
        order = Order(project="asdf", command="qwer", log_key=23, log_queue="zxcv")
        shove.parse_order = Mock(return_value=order)
        shove.execute = Mock(return_value=(0, "output"))

        shove.process_order('{"project": "asdf"}')
        shove.execute.assert_called_with(order)
        shove.adapter.send_log.assert_called_with(
            "zxcv", JSON({"version": "1.0", "log_key": 23, "return_code": 0, "output": "output"})
        )

def load_facts(config):
    import requests
    import re
    db = Shove(config['dburi'])
    db['facts'] = []
    url1 = 'http://www.cats.alpha.pl/facts.htm'
    raw = requests.get(url1).text
    filtered = filter(
            lambda l: l.startswith('<li>'),
            map(lambda l: l.strip(), raw.split('\n')))
    stripped = map(lambda l: re.sub('<[^<]+?>', '', l), filtered)
    db['facts'].extend(stripped)
    db.sync()

    def __init__(self, modeldir=None, adminsfile=None, oauthconfig=None):
        self.modeldir = modeldir
        self.admins = yaml.load(file(adminsfile,'r'))
        self.oauth_clients = Shove('sqlite:///oauth_clients.dat')
        self.users = Shove('sqlite:///oauth_users.dat')
        self.bearers = Shove('sqlite:///oauth_bearers.dat')
        self.oauthconf = yaml.load(file(oauthconfig,'r'))

        def stopper():
            print 'saving persistant data'
            self.oauth_clients.close()
            self.users.close()
            self.bearers.close()
        cherrypy.engine.subscribe('stop', stopper)

    def test_process_order_valid(self):
        """If parse_order returns a valid order, execute it and send logs back to Captain."""
        shove = Shove({})
        order = Order(project='asdf', command='qwer', log_key=23, log_queue='zxcv')
        shove.parse_order = Mock(return_value=order)
        shove.execute = Mock(return_value=(0, 'output'))

        eq_(shove.process_order('{"project": "asdf"}'), ('zxcv', JSON({
            'version': '1.0',
            'log_key': 23,
            'return_code': 0,
            'output': 'output'
        })))
        shove.execute.assert_called_with(order)

    class TestHDF5Store(Store, unittest.TestCase):

        initstring = 'hdf5://test.hdf5/test'

        def setUp(self):
            from shove import Shove
            self.store = Shove()

        def tearDown(self):
            import os
            self.store.close()
            try:
                os.remove('test.hdf5')
            except OSError:
                pass

    def test_execute_valid_order(self):
        shove = Shove({'myproject': path('test_project')})
        order = Order(project='myproject', command='pwd', log_key=5, log_queue='asdf')

        with patch('shove.base.Popen') as Popen:
            p = Popen.return_value
            p.communicate.return_value = 'command output', None
            p.returncode = 0

            return_code, output = shove.execute(order)

        Popen.assert_called_with(['pwd'], cwd=path('test_project'), stdout=PIPE, stderr=STDOUT)
        p.communicate.assert_called_with()
        eq_(return_code, 0)
        eq_(output, 'command output')