Пример #1
0
 def __init__(self, parent=None, mainwindow=None):
     super(Sign, self).__init__(parent)
     self.setupUi(self)
     self.main = mainwindow
     self.register = Register(self)
     self.passwd = Password(self)
     self.set_connect()
Пример #2
0
    def test_delete_passwords(self):
            self.new_password.save_password()
            test_password = Password("facebook","Zubeir","Abubakar","Black-heart","5250") 
            test_password.save_password()

            self.new_password.delete_passwords()
            self.assertEqual(len(Password.password_list),1)
Пример #3
0
 def test_delete_password(self):
     # check if we can remove password from our list
     self.password.save_password()
     test_password = Password("Test", "user", "*****@*****.**", "110p05124h")
     test_password.save_password()
     self.new_password.delete_password()  # deleting password
     self.assertEqual(len(Password.password_list), 1)
Пример #4
0
 def setUp(self):
     '''
     Set up method to run before each test cases.
     '''
     self.new_password = Password(
         'Evans', 'Opindi', '0740772578', '*****@*****.**',
         'evracheche1999')  # create passwordnew_password object
    def setUp(self):
        '''
        set up method to run before each test case
        '''

        self.new_password = Password("instagram", "James", "Muriuki", "cmaina",
                                     "3094")
    def test_delete_passwords(self):
        self.new_password.save_password()
        test_password = Password("instagram", "charles", "maina", "charles34",
                                 "1234")
        test_password.save_password()

        self.new_password.delete_passwords()
        self.assertEqual(len(Password.password_list), 1)
Пример #7
0
 def testBoth(self):
     f, filename = tempfile.mkstemp()
     self.addCleanup(os.unlink, filename)
     Password.KEYFILE = filename
     pwd = "Test password"
     encrypted = Password.encrypt(pwd)
     self.assertEqual(pwd, Password.decrypt(encrypted))
     self.assertEqual(os)
Пример #8
0
 def testBoth(self):
     f, filename = tempfile.mkstemp()
     self.addCleanup(os.unlink, filename)
     Password.KEYFILE = filename
     pwd = "Test password"
     encrypted = Password.encrypt(pwd)
     self.assertEqual(pwd, Password.decrypt(encrypted))
     self.assertEqual(os)
    def test_delete_password(self):

        self.new_password.save_Password()
        test_password = Password("flo", "boel", "flock", "7350")
        test_password.save_Password()

        self.new_password.delete_password()
        self.assertEqual(len(Password.password_list), 1)
Пример #10
0
    def test_password_exists(self):
        # checking if we return the booleon if the passoword is not found
        self.new_password.Password()
        test_password = Password("Test", "user", "*****@*****.**", "110p05124h")
        test_password.save_password()

        password_exists = Password.password_exists("110p05124")
        self.assertTrue(password_exists)
Пример #11
0
    def test_find_by_email(self):
        # checking if the password is in the list and the display the info
        self.new_password.save_password()
        test_password = Password("Test", "user", "wycliffkerongogmail.com", "110p05124h")
        test_password.save_password()
        found_password = Password.find_by_email("31740141")

        self.assertEqual(found_password.email, password.email)
Пример #12
0
    def test_password_exist(self):
        self.new_account.save_password()
        test_password = Password("Test", "user", "0711223344",
                               "*****@*****.**")  # new password
        test_password.save_password()

        password_exists = Password.password_exist("0711223344")
        self.assertTrue(password_exists)
Пример #13
0
    def test_delete_password(self):
        self.new_account.save_password()
        test_password = Password("Test", "user", "0712345678",
                               "*****@*****.**")  # new password
        test_password.save_password()

        self.new_account.delete_password()  # deleting a password objeect
        self.assertEqual(len(Password.password_list), 1)
Пример #14
0
 def test_save_multiple_password(self):
     '''
     test_save_multiple_password to check if we can save multiple password
     objects to our password_list
     '''
     self.new_password.save_password()
     test_password = Password("Micah", "Mutugi", "python")  # new password
     test_password.save_password()
     self.assertEqual(len(Password.password_list), 2)
Пример #15
0
 def test_save_multiple_password(self):
     '''
     test_save_multiple_password to check if we can save multiple password
     objects to our password_list
     '''
     self.new_password.save_password()
     test_password = Password("Test","user","0746432419","*****@*****.**") # new password
     test_password.save_password()
     self.assertEqual(len(Password.password_list),2)
Пример #16
0
    def test_find_password_by_number(self):
        self.new_account.save_password()
        test_password = Password("Test", "user", "0711223344",
                               "*****@*****.**")  # new password
        test_password.save_password()

        found_password = Password.find_by_number("0711223344")

        self.assertEqual(found_password.email, test_password.email)
Пример #17
0
    def test_copy_email(self):
        '''
        Test to confirm that we are copying the email address from a found contact
        '''

        self.new_password.save_password()
        Password.copy_email("0740772578")

        self.assertEqual(self.new_password.email, pyperclip.paste())
Пример #18
0
    def test_password_exist(self):

        self.new_password.save_Password
        test_password = Password("flo", "boel", "flock", "7350")
        test_password.save_Password()

        password_exist = Password.password_exist("flock")

        self.assertTrue(password_exist)
Пример #19
0
 def test_save_multiple_password(self):
     '''
     test_save_multiple_password to check if we can save multiple password
     objects to our password-locker
     '''
     self.new_password.save_password()
     test_password = Password("jasonmk", "RJXP2I5")
     test_password.save_password()
     self.assertEqual(len(Password.password_locker), 2)
Пример #20
0
    def test_find_password_by_user_name(self):

        self.new_password.save_Password()
        test_password = Password("flo", "boel", "flock", "7350")
        test_password.save_Password()

        found_password = Password.find_by_user_name("flock")

        self.assertEqual(found_password.password, test_password.password)
Пример #21
0
    def test_delete_password(self):
        '''
        test_delete_password to test if we can remove a password from our password list
        '''
        self.new_password.save_password()
        test_password = Password("Test","user","0746432419","*****@*****.**") # new password
        test_password.save_password()

        self.new_Password.delete_password()# Deleting a password object
        self.assertEqual(len(Password.password_list),1)
Пример #22
0
    def test_delete_password(self):
        '''
        test_delete_password to test if we can remove a password from our password list
        '''
        self.new_password.save_password()
        test_password = Password("Micah", "Mutugi", "python")  # new password
        test_password.save_password()

        self.new_password.delete_password()  # Deleting a password object
        self.assertEqual(len(Password.password_list), 1)
Пример #23
0
    def test_find_password_by_number(self):
        '''
        test to check if we can find a password by phone number and display information
        '''

        self.new_password.save_password()
        test_password = Password("Micah", "Mutugi", "python")  # new password
        test_password.save_password()

        found_password = Password.find_by_number("python")
Пример #24
0
    def test_delete_password(self):
        '''
        test_delete_password to test if we can remove a password from our password_locker
        '''
        self.new_password.save_password()
        test_password = Password("jasonmk", "RJXP2I5")
        test_password.save_password()

        self.new_password.delete_password()
        self.assertEqual(len(Password.password_locker), 1)
Пример #25
0
    def create_cred(self, service, username, password=None):
        if password is None:
            password = Password.generate(mn=64)

        new_entry = {
            "username": username,
            "password": Password().encrypt(password).decode()
        }
        self.creds[service] = new_entry
        Pwdfile().write(self.creds)
Пример #26
0
 def test_save_multiple_password(self):
     '''
         test_save_multiple_contact to check if we can save multiple contact
         objects to our contact_list
         '''
     self.new_password.save_password()
     test_password = Password("Test", "user", "0740772578", "*****@*****.**",
                              "evracheche1999")  # new contact
     test_password.save_password()
     self.assertEqual(len(Password.password_list), 2)
Пример #27
0
    def test_password_exists(self):
        '''
        test to check if we can return a Boolean if we cannot find the password.
        '''

        self.new_password.save_password()
        test_password = Password("jasonmk", "RJXP2I5")
        test_password.save_password()

        password_exists = Password.password_exist("jasonmk")
        self.assertTrue(password_exists)
Пример #28
0
    def test_delete_password(self):
        '''
            test_delete_contact to test if we can remove a contact from our contact list
            '''
        self.new_password.save_password()
        test_password = Password("Test", "user", "0740772575", "*****@*****.**",
                                 "evracheche1999")  # new contact
        test_password.save_password()

        self.new_password.delete_password()  # Deleting a contact object
        self.assertEqual(len(Password.password_list), 1)
Пример #29
0
    def test_password_exists(self):
        '''
        test to check if we can return a Boolean  if we cannot find the contact.
        '''

        self.new_password.save_password()
        test_password = Password("Micah", "Mutugi", "python")  # new password
        test_password.save_password()

        password_exists = Password.password_exist("python")

        self.assertTrue(password_exists)
Пример #30
0
def download(download_hash):

    if not download_hash:
        return response(request, 'No download hash specified', 400)

    if re.search('[^A-Za-z0-9_]', download_hash):
        return response(request, 'invalid download hash', 400)

    fb = FbQuery()
    # fetch file
    f = fb.file_get(download_hash)

    if not f:
        return response(request, 'Could not find file', 404)

    if f.expire != '0':
        # Expire date exists
        if fb.file_expired(f.expire):
            # Remove expired file from storage and database
            fb.file_remove(download_hash, f.filename)
            return response(request, 'This download has expired', 410)

    if f.download_password:
        # This file is password protected.
        if request.method == 'POST':
            # Validate download_password from database with user input
            pw = Password(config.get('settings', 'secret_key'))
            if not pw.validate(f.download_password, request.form['password']):
                return render_template('download.html',
                                       error='Invalid Password')

        else:
            return render_template('download.html', error=None)

    if f.one_time_download:
        # Set expire date to current time, download will be invalid in a minute
        fb.file_set_expiry(download_hash,
                           datetime.now().strftime('%Y%m%d%H%M%S'))

    # Serve images in browser
    type = guess_type(
        os.path.join(app.config['UPLOAD_FOLDER'], download_hash,
                     f.filename))[0]
    attachment = True
    if type and 'image' in type:
        attachment = False

    # Serve file, everything is ok
    return send_from_directory(os.path.join(app.config['UPLOAD_FOLDER'],
                                            download_hash),
                               f.filename,
                               as_attachment=attachment,
                               cache_timeout=0)
Пример #31
0
    def __init__(self, name, type, defaults=None, **kwargs):
        super(Config, self).__init__(defaults=defaults, **kwargs)
        self._name = name
        self._type = type

        if self._type not in VIRTWHO_TYPES:
            raise InvalidOption('Invalid type "%s", must be one of following %s' %
                                (self._type, ", ".join(VIRTWHO_TYPES)))

        for password_option, decrypted_option in self.PASSWORD_OPTIONS:
            try:
                pwd = self._options[password_option]
            except KeyError:
                continue
            try:
                self._options[decrypted_option] = Password.decrypt(unhexlify(pwd))
            except (TypeError, IndexError):
                raise InvalidPasswordFormat(
                    "Option \"{option}\" in config named \"{name}\" can't be decrypted, possibly corrupted"
                    .format(option=password_option, name=name))

        for old_name, new_name in self.RENAMED_OPTIONS:
            try:
                self._options[new_name] = self._options[old_name]
            except KeyError:
                pass

        for option in self.LATIN1_OPTIONS:
            value = self._options.get(option)
            if not value:
                continue
            try:
                value.encode('latin1')
            except UnicodeDecodeError:
                raise InvalidOption("Option '{}' is not in latin1 encoding".format(option))
Пример #32
0
    def fromParser(self, name, parser):
        type = parser.get(name, "type").lower()
        server = username = password = owner = env = None
        if type != 'libvirt':
            server = parser.get(name, "server")
            username = parser.get(name, "username")

            try:
                password = parser.get(name, "password")
            except NoOptionError:
                password = None
            if password is None:
                try:
                    crypted = parser.get(name, "encrypted_password")
                    password = Password.decrypt(crypted)
                except NoOptionError:
                    password = None

            try:
                owner = parser.get(name, "owner")
            except NoOptionError:
                owner = None
            try:
                env = parser.get(name, "env")
            except NoOptionError:
                env = None
        return Config(name, type, server, username, password, owner, env)
Пример #33
0
 def testDecrypt(self):
     self.assertEqual(
         Password._crypt(
             Password.DECRYPT,
             '06a9214036b8a15b512e03d534120006',
             '3dafba429d9eb430b422da802c9fac41',
             unhexlify('e353779c1079aeb82708942dbe77181a')),
         'Single block msg')
Пример #34
0
    def testCryptedPassword(self, password):
        from password import Password
        password.return_value = (hexlify(Password._generate_key()), hexlify(Password._generate_key()))
        passwd = "TestSecretPassword!"
        crypted = hexlify(Password.encrypt(passwd))

        filename = os.path.join(self.config_dir, "test.conf")
        with open(filename, "w") as f:
            f.write("""
[test]
type=esx
server=1.2.3.4
username=admin
encrypted_password=%s
owner=root
env=staging
""" % crypted)
        manager = ConfigManager(self.logger, self.config_dir)
        self.assertEqual(len(manager.configs), 1)
        self.assertEqual(manager.configs[0].password, passwd)
Пример #35
0
 def _get_password(self, option_name, encryped_option_name):
     pwd = self._options.get(option_name, None)
     if pwd is None:
         encrypted_password = self._options.get(encryped_option_name, None)
         if encrypted_password is None:
             return None
         try:
             pwd = Password.decrypt(unhexlify(encrypted_password))
         except TypeError:
             raise InvalidPasswordFormat("Password can't be decrypted, possibly corrupted")
     return pwd
Пример #36
0
 def _read_password(self, name, parser):
     try:
         password = parser.get(name, "password")
     except NoOptionError:
         password = None
     if password is None:
         try:
             crypted = parser.get(name, "encrypted_password")
             password = Password.decrypt(password)
         except NoOptionError:
             return None
Пример #37
0
    def _login(self):
        self._reload()
        self._open()
        self._select_form("login_form")

        password = Password.get(self.user)
        # @TODO remove
        password = password.replace("\n", "")
        self.user = self.user.replace("\n", "")

        self.browser["name"] = self.user
        self.browser["pass"] = password
        return self.browser.submit()
Пример #38
0
    def get_current_user(self):
        """Set current user, authenticated via HTTP basic auth"""

        auth_header = self.request.headers.get('Authorization')
        if auth_header is None or not auth_header.startswith('Basic '):
            return None
        auth_decoded = base64.decodestring(auth_header[6:])
        if not auth_decoded.count(':'):
            return None
        login, password = auth_decoded.split(':', 2)
        if not login or not password: return None

        try:
            encrypted_password = self.mongo.user.find_one({'_id': login},
                    {'password': 1})['password']
        except:
            return None
        if encrypted_password and Password.verify(password, encrypted_password):
            return login
        else:
            return None
Пример #39
0
    def fromParser(self, name, parser):
        type = parser.get(name, "type").lower()
        server = username = password = owner = env = None
        try:
            server = parser.get(name, "server")
        except NoOptionError:
            # Use '' as libvirt url when not given, for backward compatibility
            if type == 'libvirt':
                server = ''
            else:
                raise
        try:
            username = parser.get(name, "username")
        except NoOptionError:
            username = None

        try:
            password = parser.get(name, "password")
        except NoOptionError:
            password = None
        if password is None:
            try:
                crypted = parser.get(name, "encrypted_password")
                password = Password.decrypt(unhexlify(crypted))
            except NoOptionError:
                password = None

        try:
            owner = parser.get(name, "owner")
        except NoOptionError:
            owner = None
        try:
            env = parser.get(name, "env")
        except NoOptionError:
            env = None
        return Config(name, type, server, username, password, owner, env)
Пример #40
0
 def test_not_has_two_pairs(self):
     self.assertEqual(False, Password.containTwoPairsOfLetters("aaaaaaaa"))
     self.assertEqual(False, Password.containTwoPairsOfLetters("aaaaaaab"))
     self.assertEqual(False, Password.containTwoPairsOfLetters("baaaaaab"))
     self.assertEqual(False, Password.containTwoPairsOfLetters("abababab"))
     self.assertEqual(False, Password.containTwoPairsOfLetters("aaaacbaa"))
Пример #41
0
 def test_problem_input(self):
     self.assertEqual(True, Password.containTwoPairsOfLetters("abbceffg"))
     self.assertEqual(False, Password.containTwoPairsOfLetters("abbcegjk"))
Пример #42
0
        print """Utility that encrypts passwords for virt-who.

Enter password that should be encrypted. This encrypted password then can be
supplied to virt-who configuration.

This command must be executed as root!

WARNING: root user can still decrypt encrypted passwords!
"""
        sys.exit(0)

    if os.getuid() != 0:
        print >> sys.stderr, "Only root can encrypt passwords"
        sys.exit(1)

    try:
        pwd = getpass("Password: "******"Keyfile %s doesn't exist and can't be created, rerun as root" % Password.KEYFILE
        sys.exit(1)
    except InvalidKeyFile:
        print >> sys.stderr, "Can't access keyfile %s, rerun as root" % Password.KEYFILE
        sys.exit(1)
    print >> sys.stderr, "Use following as value for encrypted_password key in the configuration file:"
    print hexlify(enc)
Пример #43
0
def main():
    parser = OptionParser(usage="%prog <template> [options]")

    # Defaulted
    parser.add_option("-c", "--config", dest="config", help="full path to YAML config file", default=Config.DEFAULT_CONFIG_FILE)

    # Defaulted
    parser.add_option("-a", "--all", dest="auto_all", action="store_true", help="automatically create all of the subtasks in the template")

    # One of these is required
    parser.add_option("-s", "--story", dest="story" , help="Story text to use for the parent story")
    parser.add_option("-i", "--issue", dest="issue", help="JIRA Issue to create all the subtasks under")

    # Most likely in config.yaml, but overridable
    parser.add_option("-e", "--assignee", dest="assignee", help="username of JIRA user to assign tasks and subtasks to")
    parser.add_option("-p", "--project_id", dest="project_id", help="name of template to work from")
    parser.add_option("-j", "--jira", dest="jira", help="JIRA api URL")
    parser.add_option("-u", "--username", dest="username", help="username to log into JIRA with")

    # Most likely defaulted, but possibly from config.yaml
    parser.add_option("-d", "--template_dir", dest="template_dir", help="name of template to work from")

    (options, args) = parser.parse_args()

    if len(args) != 1:
        die('template name not given')

    if not os.path.isfile(options.config):
        die("Config file '%s' does not exist or is not a file" % options.config)

    if not os.access(options.config, os.R_OK):
        die("Config file '%s' is not readable" % options.config)

    if options.story is None and options.issue is None:
        die("You must specify either a JIRA story (-s, --story) to create or a JIRA issue (-i, --issue) to modify")

    template=args[0]

    with open(options.config, 'r') as config_yaml:
        config_dict = yaml.load(config_yaml)


    password = Password()
    config = Config(password.password, template, options, config_dict)

    options = {
        'server': config.jira,
        'rest_api_version' : "latest",
    }

    jira = JIRA(options, basic_auth=(config.username, config.password))
    template = Template(jira, config.assignee, config.template_dir, config.template, config.auto_all, config_dict["issue_config"])

    if config.is_story():
        print "Creating story with description: '%s'" % config.story
        parent = jira.create_issue(config.story)
    else:
        print "Adding sub-tasks to issue: '%s'" % config.issue
        parent = jira.issue(config.issue)

    print parent
    print parent.fields.project.key

    subtasks = template.add_subtasks(parent)
    for subtask in subtasks:
        print subtask
    password.cache_password()
Пример #44
0
 def test_from_problem(self):
     self.assertEqual(True, Password.isValid("abcdffaa"))
Пример #45
0
 def testBackslash(self):
     self.mock_pwd_file()
     pwd = 'abc\\def'
     self.assertEqual(
         Password.decrypt(Password.encrypt(pwd)),
         pwd)
Пример #46
0
 def test_from_problem(self):
     self.assertEqual("abcdffaa", Password.getNextPassword("abcdefgh"))
     # takes 3 minutes to run 
     self.assertEqual("ghjaabcc", Password.getNextPassword("ghijklmn"))
Пример #47
0
 def testUnpad(self):
     self.assertEqual(hexlify(Password._unpad(unhexlify("00010203040506070809060606060606"))), "00010203040506070809")
Пример #48
0
from password import Password


userInput = ''
userPassword = Password()


while userInput != ":q!":
	userInput = input("Enter Password\n")

	userPassword.setPassword(userInput)
	userPassword.calculateScore()
	#userPassword.printReport()
	userPassword.printScore()
Пример #49
0
from password import Password
#part 1
print (Password.getNextPassword("vzbxkghb"))
#part 2
print (Password.getNextPassword(Password.getNextPassword("vzbxkghb")))
Пример #50
0
 def test_one_rollover(self):
     result = Password.increment("aaaaaaaz")
     self.assertEqual("aaaaaaba", result)
Пример #51
0
    def fromParser(self, name, parser):
        type = parser.get(name, "type").lower()
        server = username = password = owner = env = rhsm_username = rhsm_password = None
        try:
            server = parser.get(name, "server")
        except NoOptionError:
            # Use '' as libvirt url when not given, for backward compatibility
            if type in ["libvirt", "vdsm", "fake"]:
                server = ""
            else:
                raise
        try:
            username = parser.get(name, "username")
        except NoOptionError:
            username = None

        try:
            password = parser.get(name, "password")
        except NoOptionError:
            try:
                encrypted_password = parser.get(name, "encrypted_password")
                password = Password.decrypt(unhexlify(encrypted_password))
            except TypeError:
                raise InvalidPasswordFormat("Password can't be decrypted, possibly corrupted")
            except NoOptionError:
                password = None

        try:
            owner = parser.get(name, "owner")
        except NoOptionError:
            owner = None
        try:
            env = parser.get(name, "env")
        except NoOptionError:
            env = None

        try:
            rhsm_username = parser.get(name, "rhsm_username")
        except NoOptionError:
            rhsm_username = None

        try:
            rhsm_password = parser.get(name, "rhsm_password")
        except NoOptionError:
            rhsm_password = None

        # Only attempt to get the encrypted rhsm password if we have a username:
        if rhsm_username is not None and rhsm_password is None:
            try:
                encrypted_rhsm_password = parser.get(name, "rhsm_encrypted_password")
                rhsm_password = Password.decrypt(unhexlify(encrypted_rhsm_password))
            except NoOptionError:
                rhsm_password = None

        try:
            rhsm_hostname = parser.get(name, "rhsm_hostname")
        except NoOptionError:
            rhsm_hostname = None

        try:
            rhsm_port = parser.get(name, "rhsm_port")
        except NoOptionError:
            rhsm_port = None

        try:
            rhsm_prefix = parser.get(name, "rhsm_prefix")
        except NoOptionError:
            rhsm_prefix = None

        try:
            rhsm_proxy_hostname = parser.get(name, "rhsm_proxy_hostname")
        except NoOptionError:
            rhsm_proxy_hostname = None

        try:
            rhsm_proxy_port = parser.get(name, "rhsm_proxy_port")
        except NoOptionError:
            rhsm_proxy_port = None

        try:
            rhsm_proxy_user = parser.get(name, "rhsm_proxy_user")
        except NoOptionError:
            rhsm_proxy_user = None

        try:
            rhsm_proxy_password = parser.get(name, "rhsm_proxy_password")
        except NoOptionError:
            try:
                encrypted_password = parser.get(name, "rhsm_encrypted_proxy_password")
                rhsm_proxy_password = Password.decrypt(unhexlify(encrypted_password))
            except TypeError:
                raise InvalidPasswordFormat("RHSM proxy password can't be decrypted, possibly corrupted")
            except NoOptionError:
                rhsm_proxy_password = None

        try:
            rhsm_insecure = parser.get(name, "rhsm_insecure")
        except NoOptionError:
            rhsm_insecure = None

        config = Config(
            name,
            type,
            server,
            username,
            password,
            owner,
            env,
            rhsm_username,
            rhsm_password,
            rhsm_hostname,
            rhsm_port,
            rhsm_prefix,
            rhsm_proxy_hostname,
            rhsm_proxy_port,
            rhsm_proxy_user,
            rhsm_proxy_password,
            rhsm_insecure,
        )

        try:
            config.hypervisor_id = parser.get(name, "hypervisor_id")
        except NoOptionError:
            config.hypervisor_id = "uuid"

        try:
            config.filter_host_uuids = parse_list(parser.get(name, "filter_host_uuids"))
        except NoOptionError:
            config.filter_host_uuids = None

        try:
            config.exclude_host_uuids = parse_list(parser.get(name, "exclude_host_uuids"))
        except NoOptionError:
            config.exclude_host_uuids = None

        if type == "esx":
            try:
                config.esx_simplified_vim = parser.get(name, "simplified_vim").lower() not in ("0", "false", "no")
            except NoOptionError:
                pass
            try:
                config.filter_host_parents = parse_list(parser.get(name, "filter_host_parents"))
            except NoOptionError:
                config.filter_host_parents = None

            try:
                config.exclude_host_parents = parse_list(parser.get(name, "exclude_host_parents"))
            except NoOptionError:
                config.exclude_host_parents = None
        elif type == "fake":
            try:
                config.fake_is_hypervisor = parser.get(name, "is_hypervisor").lower() not in ("0", "false", "no")
            except NoOptionError:
                pass
            config.fake_file = parser.get(name, "file")

        return config
Пример #52
0
 def test_has_two_pairs(self):
     self.assertEqual(True, Password.containTwoPairsOfLetters("aabbqwer"))
     self.assertEqual(True, Password.containTwoPairsOfLetters("aaxbbqwe"))
     self.assertEqual(True, Password.containTwoPairsOfLetters("bbqweraa"))
     self.assertEqual(True, Password.containTwoPairsOfLetters("qwerxxaa"))
Пример #53
0
 def test_problem_input(self):
     self.assertEqual(True, Password.containsInvalidCharacter("hijklmmn"))
Пример #54
0
 def test_Password___test_lenght(self):
     password = Password('admin0')
     self.assertFalse(password._Password___check_password())
Пример #55
0
 def test_valid(self):
     self.assertEqual(False, Password.containsInvalidCharacter("aaabaaaa"))
Пример #56
0
 def testBoth(self):
     self.mock_pwd_file()
     pwd = "Test password"
     encrypted = Password.encrypt(pwd)
     self.assertEqual(pwd, Password.decrypt(encrypted))
Пример #57
0
 def testCryptedPasswordWithoutKey(self):
     from password import Password, InvalidKeyFile
     Password.KEYFILE = "/some/nonexistant/file"
     passwd = "TestSecretPassword!"
     with self.assertRaises(InvalidKeyFile):
         Password.decrypt(unhexlify("06a9214036b8a15b512e03d534120006"))
Пример #58
0
 def testPercent(self):
     self.mock_pwd_file()
     pwd = 'abc%%def'
     self.assertEqual(
         Password.decrypt(Password.encrypt(pwd)),
         pwd)
Пример #59
-1
 def testBoth(self):
     f, filename = tempfile.mkstemp()
     self.addCleanup(os.unlink, filename)
     Password.KEYFILE = filename
     pwd = "Test password"
     Password._can_write = MagicMock(retun_value=True)
     encrypted = Password.encrypt(pwd)
     self.assertEqual(pwd, Password.decrypt(encrypted))