Beispiel #1
0
	def test_profile_password_mismatch(self):
		repo = MemorySecurityRepo(MEMORY_SESSION)
		repo_profile = MemoryProfileRepo(MEMORY)

		profile = Profile('test', Password('test', Sha256Hasher))
		self.assertTrue(repo_profile.create(profile))

		profile_invalid = Profile('test', Password('test2', Sha256Hasher))
		login_uc = LoginUseCase(repo, repo_profile)
		session = login_uc.login(SALT, profile_invalid, _on_success_cb)

		self.assertIsInstance(session, State)
		self.assertEqual(session.name, login_uc.STATE_NAME)
		self.assertEqual(session.status, login_uc.STATE_FAILED_PASSWORD_MISMTACH)
Beispiel #2
0
 def create(self, profile: Profile) -> bool:
     id = str(uuid.uuid4())
     new_password = Password(profile.password.raw, Sha256Hasher,
                             profile.password.to_hash())
     new_profile = Profile(profile.name, new_password, id)
     self.in_memory[profile.name] = new_profile
     return new_profile
Beispiel #3
0
    def test_get_list_success(self):
        repo = MemoryProfileRepo()
        profile1 = Profile('myname', Password('mypassword', Sha256Hasher))
        profile2 = Profile('myname2', Password('mypassword', Sha256Hasher))

        register_case = RegisterUseCase(repo)
        register_case.register(profile1)
        register_case.register(profile2)

        profiles_case = ProfilesUseCase(repo)
        profiles = profiles_case.profiles({'names': ['myname', 'myname2']})

        self.assertEqual(2, len(profiles))

        profile1_from_db = profiles[0]
        self.assertEqual('myname', profile1_from_db.name)
Beispiel #4
0
	def test_unlock_success(self):
		password = Password(raw='test_password', hasher=Sha256Hasher)
		profile = Profile(name='test_name', password=password)

		repo = ProfileRepository(config())
		saved = repo.create(profile)
		self.assertTrue(saved)

		payload = {'name': profile.name}
		token = Token(salt='test_salt', payload=payload, builder=JWTToken)
		session = Session(token=token, locked=False, profile_id=saved.id)

		repo_sec = SecurityRepository(config())
		session_id = repo_sec.register(session)
		session = repo_sec.get(session_id)

		self.assertIsInstance(session, Session)
		self.assertEqual(session.token, token.build().decode())
		self.assertEqual(session.profile_id, str(saved.id))
		self.assertFalse(session.locked)

		repo_sec.lock(id=session_id)
		session = repo_sec.get(session_id)
		self.assertTrue(session.locked)
		
		repo_sec.unlock(id=session_id)
		session = repo_sec.get(session_id)
		self.assertFalse(session.locked)
Beispiel #5
0
    def test_register_validation_name_exist(self):
        with self.assertRaises(ValidationError):
            repo = MemoryProfileRepo()
            usecase = RegisterUseCase(repo)
            profile = Profile('name', Password('mypassword', Sha256Hasher))

            usecase.register(profile)  # should be success
            usecase.register(profile)  # name should be cannot pass validation
Beispiel #6
0
    def test_get_list(self):
        password = Password(raw='test_password', hasher=Sha256Hasher)
        profile = Profile(name='test_name', password=password)

        password2 = Password(raw='test_password', hasher=Sha256Hasher)
        profile2 = Profile(name='test_name', password=password)

        repo = ProfileRepository(config())
        repo.create(profile)
        repo.create(profile2)

        docs = repo.get_list({'filter': {'name': 'test_name'}})

        self.assertIsInstance(docs, list)
        self.assertEqual(2, len(docs))

        doc1 = docs[0]
        self.assertEqual(doc1.name, profile.name)
Beispiel #7
0
	def test_profile_not_valid_no_password(self):
		repo = MemorySecurityRepo(MEMORY_SESSION)
		repo_profile = MemoryProfileRepo(MEMORY)

		profile = Profile('test', Password('', Sha256Hasher))
		login_uc = LoginUseCase(repo, repo_profile)
		
		with self.assertRaises(ValidationError):
			session = login_uc.login(SALT, profile, _on_success_cb)
Beispiel #8
0
    def test_remove_success(self):
        password = Password(raw='test_password', hasher=Sha256Hasher)
        profile = Profile(name='test_name', password=password)

        repo = ProfileRepository(config())
        self.assertTrue(repo.create(profile))
        self.assertTrue(repo.remove(profile.name))

        doc = repo.get_detail(profile.name)
        self.assertIsNone(doc)
Beispiel #9
0
    def test_get_by_name(self):
        password = Password(raw='test_password', hasher=Sha256Hasher)
        profile = Profile(name='test_name', password=password)

        repo = ProfileRepository(config())
        self.assertTrue(repo.create(profile))

        doc = repo.get_detail(profile.name)
        self.assertIsNotNone(doc)
        self.assertEqual(doc.name, profile.name)
Beispiel #10
0
    def test_register_name_exist(self):
        password = Password(raw='test_password', hasher=Sha256Hasher)
        profile = Profile(name='test_name', password=password)

        repo = ProfileRepository(config())
        saved = repo.create(profile)

        adapter = RegisterAdapter(repo)
        with self.assertRaises(ValidationError):
            adapter.register(saved.name, 'test_pass')
Beispiel #11
0
    def test_create_success(self):
        password = Password(raw='test_password', hasher=Sha256Hasher)
        profile = Profile(name='test_name', password=password)

        repo = ProfileRepository(config())
        saved = repo.create(profile)
        self.assertTrue(saved)
        self.assertEqual(saved.name, profile.name)
        self.assertEqual(saved.password, profile.password.to_hash())
        self.assertIsNotNone(saved.id)
Beispiel #12
0
    def register(self, name: str, password: str) -> Profile:
        """Register new profile based on given name and password
		
		Raises:
			core.shared.exceptions.ValidationError: if profile not passed validation process
			core.shared.exceptions.StorageError: if there is an error related with datastorage 
		"""
        password = Password(raw=password, hasher=Sha256Hasher)
        profile = Profile(name=name, password=password)
        return self.usecase.register(profile)
Beispiel #13
0
	def test_delete_success(self):
		repo = MemoryProfileRepo()
		profile = Profile('myname', Password('mypassword', Sha256Hasher))
		
		register_case = RegisterUseCase(repo)
		delete_case = DeleteUseCase(repo)

		self.assertTrue(register_case.register(profile))
		self.assertTrue(delete_case.remove(profile.name))

		check = repo.get_detail(profile.name)
		self.assertIsNone(check)
Beispiel #14
0
	def test_profile_not_exist(self):
		repo = MemorySecurityRepo(MEMORY_SESSION)
		repo_profile = MemoryProfileRepo(MEMORY)

		profile = Profile('test', Password('test', Sha256Hasher))
		login_uc = LoginUseCase(repo, repo_profile)

		session = login_uc.login(SALT, profile, _on_success_cb)

		self.assertIsInstance(session, State)
		self.assertEqual(session.name, login_uc.STATE_NAME)
		self.assertEqual(session.status, login_uc.STATE_FAILED_NO_PROFILE)
Beispiel #15
0
	def test_success(self):
		repo = MemorySecurityRepo(MEMORY_SESSION)
		repo_profile = MemoryProfileRepo(MEMORY)

		profile = Profile('test', Password('test', Sha256Hasher))
		self.assertTrue(repo_profile.create(profile))

		login_uc = LoginUseCase(repo, repo_profile)
		session = login_uc.login(SALT, profile, _on_success_cb)
		
		self.assertFalse(isinstance(session, State))
		self.assertIsNotNone(session.id)
		self.assertIsNone(session.token.options)
		self.assertTrue(isinstance(session.token.build(), str))
Beispiel #16
0
    def test_delete_session_using_none(self):
        repo = MemorySecurityRepo(MEMORY_SESSION)
        repo_profile = MemoryProfileRepo(MEMORY)

        profile = Profile('test', Password('test', Sha256Hasher))
        self.assertTrue(repo_profile.create(profile))

        login_uc = LoginUseCase(repo, repo_profile)
        session = login_uc.login(SALT, profile, _on_success_cb)
        self.assertFalse(isinstance(session, State))
        self.assertIsNotNone(session.id)

        logout_uc = LogoutUseCase(repo, repo_profile)
        logout_uc.logout()
        self.assertFalse(repo.is_exist())
Beispiel #17
0
    def login(self, name: str, password: str) -> Union[State, Session]:
        """Logging in users

		Raises:
			autowp.core.shared.exceptions.VarTypeError: When given profile is not an instance of Profile
			autowp.core.shared.exceptions.ValidationError: When cannot validate given profile entity
		"""
        if self.repo.is_exist():
            sess_prev = self.repo.get()
            if sess_prev:
                self.repo.remove(sess_prev.id)

        password = Password(raw=password, hasher=Sha256Hasher)
        profile = Profile(name=name, password=password)
        session = self.usecase.login(self.config.salt, profile,
                                     self._login_success_callback)
        return session
Beispiel #18
0
	def test_remove_success(self):
		password = Password(raw='test_password', hasher=Sha256Hasher)
		profile = Profile(name='test_name', password=password)

		repo = ProfileRepository(config())
		saved = repo.create(profile)
		self.assertTrue(saved)

		payload = {'name': profile.name}
		token = Token(salt='test_salt', payload=payload, builder=JWTToken)
		session = Session(token=token, locked=False, profile_id=saved.id)

		repo_sec = SecurityRepository(config())
		session_id = repo_sec.register(session)
		self.assertIsInstance(session_id, str)
		self.assertTrue(repo_sec.remove(session_id))
		self.assertFalse(repo_sec.is_exist())
Beispiel #19
0
    def test_get_profile_success(self):
        repo = MemorySecurityRepo(MEMORY_SESSION)
        repo_profile = MemoryProfileRepo(MEMORY)

        profile = Profile('test', Password('test', Sha256Hasher))
        self.assertTrue(repo_profile.create(profile))

        login_uc = LoginUseCase(repo, repo_profile)
        session = login_uc.login(SALT, profile, _on_success_cb)

        self.assertFalse(isinstance(session, State))
        self.assertIsNotNone(session.id)
        self.assertIsNotNone(session.profile_id)

        current_profile_uc = CurrentProfileUseCase(repo, repo_profile)
        current_profile = current_profile_uc.current_profile()
        self.assertIsNotNone(current_profile)
        self.assertIsInstance(current_profile, Profile)
Beispiel #20
0
 def test_register_validation_no_password(self):
     with self.assertRaises(ValidationError):
         repo = MemoryProfileRepo()
         usecase = RegisterUseCase(repo)
         profile = Profile('name', Password('', Sha256Hasher))
         usecase.register(profile)
Beispiel #21
0
    def test_register_success(self):
        repo = MemoryProfileRepo()
        usecase = RegisterUseCase(repo)
        profile = Profile('myname', Password('mypassword', Sha256Hasher))

        self.assertTrue(usecase.register(profile))
Beispiel #22
0
 def create(self, profile: Profile) -> bool:
     new_password = Password(profile.password.raw, Sha256Hasher,
                             profile.password.to_hash())
     self.in_memory[profile.name] = Profile(profile.name, new_password)
     return True
Beispiel #23
0
	def create(self, profile: Profile) -> Profile:
		new_password = Password(profile.password.raw, Sha256Hasher, profile.password.to_hash())
		new_profile = Profile(profile.name, new_password)
		self.in_memory[profile.name] = new_profile
		return new_profile