def test_get(self):
     old_engine = CryptoEngine.get()
     self.assertIsInstance(old_engine, CryptoEngineOld)
     CryptoEngine._instance = None
     new_engine = CryptoEngine.get(dbver=0.5)
     self.assertIsInstance(new_engine, CryptoEngine)
     self.assertFalse(isinstance(new_engine, CryptoEngineOld))
     CryptoEngine._instance = None
     old_engine = CryptoEngine.get()

    def __init__(self):
        config.set_defaults(default_config)
        enc = CryptoEngine.get(dbver=0.4)
        enc.callback = DummyCallback4()
        self.enc1 = copy.copy(enc)
        enc = CryptoEngine.get(dbver=0.5)
        enc.callback = DummyCallback4()
        self.enc2 = copy.copy(enc)

        self.db1 = SQLiteDatabaseNewForm('konverter-v0.4.db', dbformat=0.4)
        self.db2 = SQLiteDatabaseNewForm('konverter-v0.5.db', dbformat=0.5)
        assert self.enc1 is not self.enc2

 def changepassword(self):
     """
     Change the databases password.
     """
     enc = CryptoEngine.get()
     newkey = enc.changepassword()
     return self.savekey(newkey)

    def run(self):
        global AUTHENTICATED, TAGS, DB

        OSX = False
        sys.argv = []

        args = parser_options().parse_args()
        xselpath, dbtype = get_conf_options(args, OSX)
        dbver = 0.5
        DB = pwman.data.factory.create(dbtype, dbver)
        DB.open(dbver=0.5)
        print(dir(DB))
        CryptoEngine.get(dbver=0.5)
        print(pwman.config._conf)
        debug(True)
        run(port=9030)

def forget():
    global AUTHENTICATED
    AUTHENTICATED = False
    enc = CryptoEngine.get()
    enc.forget()

    redirect('/auth')

 def do_tags(self, arg):
     enc = CryptoEngine.get()
     if not enc.alive():
         enc._getcipher()
     print ("Tags: \n",)
     t = self._tags(enc)
     print ('\n'.join(t))

 def get_user_password(self):
     """
     get the databases password from the user
     """
     enc = CryptoEngine.get()
     newkey = enc.changepassword()
     return self.savekey(newkey)

    def __init__(self, db, hasxsel, callback):
        """
        initialize CLI interface, set up the DB
        connecion, see if we have xsel ...
        """
        cmd.Cmd.__init__(self)
        self.intro = "%s %s (c) visit: %s" % (pwman.appname, pwman.version, pwman.website)
        self._historyfile = config.get_value("Readline", "history")
        self.hasxsel = hasxsel
        try:
            enc = CryptoEngine.get()
            enc._callback = callback()
            self._db = db
            #  this cascades down all the way to setting the database key
            self._db.open()
        except Exception as e:  # pragma: no cover
            self.error(e)
            sys.exit(1)

        try:
            readline.read_history_file(self._historyfile)
        except IOError as e:  # pragma: no cover
            pass

        self.prompt = "pwman> "

 def test_db_change_pass(self):
     "fuck yeah, we change the password and the new dummy works"
     enc = CryptoEngine.get()
     enc._callback = DummyCallback3()
     self.tester.cli._db.changepassword()
     self.tester.cli.do_forget('')
     enc._callback = DummyCallback4()
     self.tester.cli.do_ls('')

 def get_username(self):
     """
     Return the username.
     This solution with strip is horribly assuming that
     the username does not containg space as the last character.
     The same is also true for the password.
     """
     enc = CryptoEngine.get()
     return enc.decrypt(self._username).strip()

    def read_old_db(self):
        "read the old db and get all nodes"

        self.db = SQLiteDatabaseReader()
        enc = CryptoEngine.get()
        enc.set_callback(CLICallback())
        self.db.open()
        self.oldnodes = self.db.listnodes()
        self.oldnodes = self.db.getnodes(self.oldnodes)

    def open(self):
        """Open the database."""
        self._open()

        enc = CryptoEngine.get()
        key = self.loadkey()
        if key != None:
            enc.set_cryptedkey(key)
        else:
            self.changepassword()

    def __init__(self,username="",password="",url="",notes="",tags=[]):
        """Initialise everything to null."""
        self._id = 0;

        enc = CryptoEngine.get()
        self._username = enc.encrypt(username)
        self._password = enc.encrypt(password)
        self._url = enc.encrypt(url)
        self._notes = enc.encrypt(notes)
        self._tags = []
        self.set_tags(tags)

 def complete_filter(self, text, line, begidx, endidx):
     strings = []
     enc = CryptoEngine.get()
     if not enc.alive():
         return strings
     
     tags = self._db.listtags()
     for t in tags:
         name = t.get_name()
         if name.startswith(text):
             strings.append(t.get_name())
     return strings

 def do_tags(self, arg):
     tags = self._db.listtags()
     # request password
     enc = CryptoEngine.get()
     if not enc.alive():
         enc._getcipher()
     print "Tags: ",
     if len(tags) == 0:
         print "None",
     for t in tags:
         print "%s " % t,
     print

    def __str__(self):  # pragma: no cover
        enc = CryptoEngine.get()
        try:
            tags = ', '.join([enc.decrypt(tag).strip() for tag in filter(None,
                             self._tags)])
        except Exception:
            tags = ', '.join([tag.strip() for tag in filter(None, self._tags)])

        user = enc.decrypt(self._username).strip()
        url = enc.decrypt(self._url).strip()
        return '{0}@{1}\t{2}'.format(user, url,
                                     tags)

    def __init__(self, db):
        cmd.Cmd.__init__(self)
        self.intro = "%s %s (c) %s <%s>" % (pwman.appname, pwman.version, pwman.author, pwman.authoremail)
        self._historyfile = config.get_value("Readline", "history")

        try:
            enc = CryptoEngine.get()
            enc.set_callback(CLICallback())
            self._db = db
            self._db.open()
        except Exception, e:
            self.error(e)
            sys.exit(1)

    def run(self):
        # before add nodes to db1 we have to create an encryption key!
        # this is handeld by the open method
        self.db1._open()
        enc1 = CryptoEngine.get(dbver=0.4)
        enc1.callback = DummyCallback4()
        key = self.db1.loadkey()
        if key is not None:
            enc1.set_cryptedkey(key)
        else:
            newkey = enc1.changepassword()
            self.db1.savekey(newkey)

        enc1c = copy.copy(enc1)
        if key is not None:
            enc1.set_cryptedkey(key)

        self.add_nodes_to_db1()
        CryptoEngine._instance = None

        self.db2._open()
        enc2 = CryptoEngine.get(dbver=0.5)
        enc2.callback = DummyCallback4()
        key = self.db2.loadkey()
        if key is not None:
            enc2.set_cryptedkey(key)
        else:
            newkey = enc2.changepassword()
            self.db2.savekey(newkey)

        enc2c = copy.copy(enc2)
        if key is not None:
            enc2.set_cryptedkey(key)

        self.add_nodes_to_db2()
        assert enc1 is not enc2
        assert enc1c is not enc2c

 def open(self):
     """
     Open the database, by calling the _open method of the
     class inherited for the specific database.
     When done validation that the file is OK, check if it has
     encryption key, by calling   
     enc = CryptoEngine.get()
     key = self.loadkey()
     """
     self._open()
     enc = CryptoEngine.get()
     key = self.loadkey()
     if (key != None):
         enc.set_cryptedkey(key)
     else:
         self.changepassword()

 def __init__(self, db, hasxsel):
     """
     initialize CLI interface, set up the DB
     connecion, see if we have xsel ...
     """
     cmd.Cmd.__init__(self)
     self.intro = "%s %s (c) visit: %s" % (pwman.appname, pwman.version, pwman.website)
     self._historyfile = config.get_value("Readline", "history")
     self.hasxsel = hasxsel
     try:
         enc = CryptoEngine.get()
         enc.set_callback(CLICallback())
         self._db = db
         self._db.open()
     except Exception, e:
         self.error(e)
         sys.exit(1)