def _create_social_user(self): u = User.objects.create(username='******', email='*****@*****.**') u.set_unusable_password() u.save() sa = SocialAccount(user=u, provider='facebook', uid='12345', extra_data='{}') sa.full_clean() sa.save() return u
def _add_surfconext_socialaccount(self, user): random_surfconext_id = str(uuid.uuid4()) extra_data = {"family_name": user.last_name, "sub": random_surfconext_id, "email": user.email, "name": user.get_full_name(), "given_name": user.first_name} socialaccount = SocialAccount(extra_data=extra_data, uid=random_surfconext_id, provider='surf_conext', user=user) socialaccount.save()
def dispatch(self, request, *args, **kwargs): """ Override allauth's dispatch method to transparently just login if the email already exists. By doing this in dispatch, we can check for existing email, and if a match is found, associate the social account with that user and log them in. Allauth does not provide a mechanism for doing precisely this. """ ret = super().dispatch(request, *args, **kwargs) # By calling super().dispatch first, we set self.sociallogin try: # The email is contained in sociallogin.account.extra_data extra_data = self.sociallogin.account.extra_data except AttributeError: return ret # extract email email = extra_data["email"] if email_address_exists(email): # check that email exists. # If the email does exist, and there is a social account associated # with the user, then we don't have to do anything else if not self.sociallogin.is_existing: # However, if the email exists, and there isn't a social # account associated with that user, we need to associate the # social account # Allauth would perform this as part of the form.save step, but # we are entirely bypassing the form. account_emailaddress = EmailAddress.objects.get(email=email) self.sociallogin.user = account_emailaddress.user # allauth (and us) uses the sociallogin user as a temporary # holding space, and it already is largely filled out by # allauth; we just need to set the user. # This model does not get saved to the database. # We're trusting social provided emails already account_emailaddress.verified = True account_emailaddress.save() if not SocialAccount.objects.filter( uid=self.sociallogin.account.uid, provider=self.sociallogin.account.provider, ).exists(): # just to be on the safe side, double check that the account # does not exist in the database and that the provider is # valid. socialaccount = SocialAccount() socialaccount.uid = self.sociallogin.account.uid socialaccount.provider = self.sociallogin.account.provider socialaccount.extra_data = extra_data socialaccount.user = self.sociallogin.user socialaccount.save() return complete_social_login(request, self.sociallogin) return ret
def _process_signup(request, data, account): # If email is specified, check for duplicate and if so, no auto signup. auto_signup = app_settings.AUTO_SIGNUP email = data.get('email') if auto_signup: # Let's check if auto_signup is really possible... if email: if account_settings.UNIQUE_EMAIL: if email_address_exists(email): # Oops, another user already has this address. We # cannot simply connect this social account to the # existing user. Reason is that the email adress may # not be verified, meaning, the user may be a hacker # that has added your email address to his account in # the hope that you fall in his trap. We cannot check # on 'email_address.verified' either, because # 'email_address' is not guaranteed to be verified. auto_signup = False # FIXME: We redirect to signup form -- user will # see email address conflict only after posting # whereas we detected it here already. elif account_settings.EMAIL_REQUIRED: # Nope, email is required and we don't have it yet... auto_signup = False if not auto_signup: request.session['socialaccount_signup'] = dict(data=data, account=account) url = reverse('socialaccount_signup') next = request.REQUEST.get('next') if next: url = url + '?' + urlencode(dict(next=next)) ret = HttpResponseRedirect(url) else: # FIXME: There is some duplication of logic inhere # (create user, send email, in active etc..) username = generate_unique_username \ (data.get('username', email or 'user')) u = User(username=username, email=email or '', last_name = data.get('last_name', '')[0:User._meta.get_field('last_name').max_length], first_name = data.get('first_name', '')[0:User._meta.get_field('first_name').max_length]) u.set_unusable_password() u.is_active = not account_settings.EMAIL_VERIFICATION u.save() accountbase = SocialAccount() accountbase.user = u accountbase.save() account.base = accountbase account.sync(data) send_email_confirmation(u, request=request) ret = complete_social_signup(request, u, account) return ret
def add_eduid_socialaccount(self, user): random_eduid = "urn:mace:eduid.nl:1.0:d57b4355-c7c6-4924-a944-6172e31e9bbc:{}c14-b952-4d7e-85fd-{}ac5c6f18".format(random.randint(1, 99999), random.randint(1, 9999)) extra_data = {"family_name": user.last_name, "sub": random_eduid, "email": user.email, "name": user.get_full_name(), "given_name": user.first_name} socialaccount = SocialAccount(extra_data=extra_data, uid=random_eduid, provider='edu_id', user=user) socialaccount.save() user.remove_cached_data(['cached_affiliations'])
def get_or_create_user(payload, oidc=False): user_id = payload.get('sub') if not user_id: msg = _('Invalid payload.') raise exceptions.AuthenticationFailed(msg) try_again = False try: user = _try_create_or_update(user_id, payload, oidc) except IntegrityError: # If we get an integrity error, it probably meant a race # condition with another process. Another attempt should # succeed. try_again = True if try_again: # We try again without catching exceptions this time. user = _try_create_or_update(user_id, payload, oidc) # If allauth.socialaccount is installed, create the SocialAcount # that corresponds to this user. Otherwise logins through # allauth will not work for the user later on. if 'allauth.socialaccount' in settings.INSTALLED_APPS: from allauth.socialaccount.models import SocialAccount, EmailAddress if oidc: provider_name = 'helsinki_oidc' else: provider_name = 'helsinki' args = {'provider': provider_name, 'uid': user_id} try: account = SocialAccount.objects.get(**args) assert account.user_id == user.id except SocialAccount.DoesNotExist: account = SocialAccount(**args) account.extra_data = payload account.user = user account.save() try: email = EmailAddress.objects.get(email__iexact=user.email) assert email.user == user except EmailAddress.DoesNotExist: email = EmailAddress(email=user.email.lower(), primary=True, user=user, verified=True) email.save() return user
def dispatch(self, request): app = self.adapter.get_app(request) provider_id = self.adapter.provider_id try: uid, data, extra_data = self.adapter.get_user_info(request, app) except OAuthError: return render_authentication_error(request) try: account = SocialAccount.objects.get(provider=provider_id, uid=uid) except SocialAccount.DoesNotExist: account = SocialAccount(provider=provider_id, uid=uid) account.extra_data = extra_data if account.pk: account.save() return complete_social_login(request, data, account)
def copy_fb_data(apps, schema_editor): model = apps.get_model('xsd_members', 'MemberProfile') db_alias = schema_editor.connection.alias objects = model.objects.using(db_alias).all() for obj in objects: if obj.facebook_id: sa = SocialAccount( user_id = obj.user.pk, provider = 'facebook', uid = obj.facebook_id, last_login = obj.user.last_login, date_joined = obj.user.date_joined, extra_data = obj.raw_data ) sa.save()
def dispatch(self, request): app = self.adapter.get_app(request) provider_id = self.adapter.provider_id try: uid, data, extra_data = self.adapter.get_user_info(request, app) except OAuthError: return render_authentication_error(request) try: account = SocialAccount.objects.get(provider=provider_id, uid=uid) except SocialAccount.DoesNotExist: account = SocialAccount(provider=provider_id, uid=uid) account.extra_data = extra_data if account.pk: account.save() return complete_social_login(request, data, account)
def copy_fb_data(apps, schema_editor): model = apps.get_model('xsd_members', 'MemberProfile') db_alias = schema_editor.connection.alias objects = model.objects.using(db_alias).all() for obj in objects: if obj.facebook_id: sa = SocialAccount( user_id = obj.user.pk, provider = 'facebook', uid = obj.facebook_id, last_login = obj.user.last_login, date_joined = obj.user.date_joined, extra_data = obj.raw_data ) sa.save()
def migrate_social_accounts(_, __): if 'social_auth_usersocialauth' in connection.introspection.table_names(): with connection.cursor() as cursor: OldAccount = namedtuple( 'OldAccount', ('id', 'provider', 'uid', 'extra_data', 'user_id')) cursor.execute("SELECT * FROM social_auth_usersocialauth") for row in cursor.fetchall(): row = OldAccount(*row) new_account = SocialAccount(provider=row.provider, uid=row.uid, extra_data=json.loads( row.extra_data)) new_account.user_id = row.user_id new_account.save()
def get_or_create_user(payload, oidc=False): user_id = payload.get('sub') if not user_id: msg = _('Invalid payload.') raise exceptions.AuthenticationFailed(msg) try_again = False try: user = _try_create_or_update(user_id, payload, oidc) except IntegrityError: # If we get an integrity error, it probably meant a race # condition with another process. Another attempt should # succeed. try_again = True if try_again: # We try again without catching exceptions this time. user = _try_create_or_update(user_id, payload, oidc) # If allauth.socialaccount is installed, create the SocialAcount # that corresponds to this user. Otherwise logins through # allauth will not work for the user later on. if 'allauth.socialaccount' in settings.INSTALLED_APPS: from allauth.socialaccount.models import SocialAccount, EmailAddress if oidc: provider_name = 'helsinki_oidc' else: provider_name = 'helsinki' args = {'provider': provider_name, 'uid': user_id} try: account = SocialAccount.objects.get(**args) assert account.user_id == user.id except SocialAccount.DoesNotExist: account = SocialAccount(**args) account.extra_data = payload account.user = user account.save() try: email = EmailAddress.objects.get(email__iexact=user.email) assert email.user == user except EmailAddress.DoesNotExist: email = EmailAddress(email=user.email.lower(), primary=True, user=user, verified=True) email.save() return user
def get_or_create_user(payload, oidc=False): user_id = payload.get('sub') if not user_id: msg = _('Invalid payload.') raise exceptions.AuthenticationFailed(msg) user_model = get_user_model() with transaction.atomic(): try: user = user_model.objects.select_for_update().get(uuid=user_id) except user_model.DoesNotExist: user = user_model(uuid=user_id) user.set_unusable_password() update_user(user, payload, oidc) # If allauth.socialaccount is installed, create the SocialAcount # that corresponds to this user. Otherwise logins through # allauth will not work for the user later on. if 'allauth.socialaccount' in settings.INSTALLED_APPS: from allauth.socialaccount.models import SocialAccount, EmailAddress if oidc: provider_name = 'helsinki_oidc' else: provider_name = 'helsinki' args = {'provider': provider_name, 'uid': user_id} try: account = SocialAccount.objects.get(**args) assert account.user_id == user.id except SocialAccount.DoesNotExist: account = SocialAccount(**args) account.extra_data = payload account.user = user account.save() try: email = EmailAddress.objects.get(email__iexact=user.email) assert email.user == user except EmailAddress.DoesNotExist: email = EmailAddress(email=user.email.lower(), primary=True, user=user, verified=True) email.save() return user
def test_get_redir_user_demo(self): payload = {"user": {"username": self.demo["username"]}} self.client.login(username=payload["user"]["username"], password="******") sapp = SocialApp(provider='github', name='Github', client_id='<test>', secret='<test>') sapp.save() sacc = SocialAccount(uid=1001, user=self.test_user, provider="github") sacc.save() stoken = SocialToken(app=sapp, account=sacc, token="test_token") stoken.save() response = self.client.post('/accounts/profile', follow=True) first_url, first_response = response.redirect_chain[0] self.assertEqual(first_url, "/login?status=passed&token=test_token&username=testname&user_id=1001") self.client.login(username=payload["user"]["username"], password="******") stoken = SocialToken(app=sapp, account=sacc, token="test_token") stoken.save() response = self.client.post('/accounts/profile', follow=True) first_url, first_response = response.redirect_chain[0] self.assertEqual(first_url, "/login?status=passed&token=test_token&username=testname&user_id=1001")
def complete_login(self, request, app, token, email_addresses=[]): client = TwitterAPI(request, app.client_id, app.secret, self.request_token_url) extra_data = client.get_user_info() uid = extra_data['id'] user = User.objects.filter(username=extra_data.get('screen_name')) if user: return user else: user = get_adapter() \ .populate_new_user(username=extra_data.get('screen_name'), name=extra_data.get('name')) user.save() account = SocialAccount(user=user, uid=uid, provider=TwitterProvider.id, extra_data=extra_data) account.save() application = SocialApp.objects.get(secret=app.secret) sample_token = SocialToken.objects.filter(app=application, account=account) if sample_token: token = sample_token[0] else: token = SocialToken( app=application, account=account, token=request.session["oauth_api.twitter.com_access_token"] ["oauth_token"], token_secret=request. session["oauth_api.twitter.com_access_token"] ["oauth_token_secret"]) token.save() mail = send_email_confirmation(request=request, user=user, signup=True) return SocialLogin(account=account, token=token, email_addresses=email_addresses)
def dispatch(self, request): if 'error' in request.GET or not 'code' in request.GET: # TODO: Distinguish cancel from error return render_authentication_error(request) app = self.adapter.get_app(self.request) client = self.get_client(request, app) provider_id = self.adapter.provider_id try: access_token = client.get_access_token(request.GET['code']) uid, data, extra_data = self.adapter.get_user_info( request, app, access_token) except OAuth2Error: return render_authentication_error(request) # TODO: DRY, duplicates OAuth logic try: account = SocialAccount.objects.get(provider=provider_id, uid=uid) except SocialAccount.DoesNotExist: account = SocialAccount(provider=provider_id, uid=uid) account.extra_data = extra_data if account.pk: account.save() return complete_social_login(request, data, account)
def add_teacher_social_account_to_user(user, email, surfconext_id=None): extra_data = { "family_name": "Teacher", "sub": "7980e81d94c0c5a201bf6809c51e5edc8c7d2600" if not surfconext_id else surfconext_id, "email": email, "name": "Er\\u00f4ss Neci", "given_name": "Er\\u00f4ss" } socialaccount = SocialAccount( extra_data=extra_data, uid="7980e81d94c0c5a201bf6809c51e5edc8c7d2600" if not surfconext_id else surfconext_id, provider='surf_conext', user=user) socialaccount.save()
def add_student_social_account_to_user(user, email, eduid=None): extra_data = { "family_name": "Neci", "sub": "urn:mace:eduid.nl:1.0:d57b4355-c7c6-4924-a944-6172e31e9bbc:27871c14-b952-4d7e-85fd-6329ac5c6f18" if not eduid else eduid, "email": email, "name": "Er\\u00f4ss Neci", "given_name": "Er\\u00f4ss" } socialaccount = SocialAccount( extra_data=extra_data, uid= "urn:mace:eduid.nl:1.0:d57b4355-c7c6-4924-a944-6172e31e9bbc:27871c14-b952-4d7e-85fd-6329ac5c6f18" if not eduid else eduid, provider='edu_id', user=user) socialaccount.save()
def dispatch(self, request): if 'error' in request.GET or not 'code' in request.GET: # TODO: Distinguish cancel from error return render_authentication_error(request) app = self.adapter.get_app(self.request) client = self.get_client(request, app) provider_id = self.adapter.provider_id try: access_token = client.get_access_token(request.GET['code']) uid, data, extra_data = self.adapter.get_user_info(request, app, access_token) except OAuth2Error: return render_authentication_error(request) # TODO: DRY, duplicates OAuth logic try: account = SocialAccount.objects.get(provider=provider_id, uid=uid) except SocialAccount.DoesNotExist: account = SocialAccount(provider=provider_id, uid=uid) account.extra_data = extra_data if account.pk: account.save() return complete_social_login(request, data, account)
def social_user(): profile = factories.UserProfileFactory.create( user__email='*****@*****.**') user = profile.user user.set_password('password') account = SocialAccount( user_id=user.id, extra_data={ 'id': user.id, 'email': user.email, 'verified_email': True, 'name': 'Jim Example', 'given_name': 'Jim', 'family_name': 'Example', 'locale': 'en', }, provider='google', ) account.save() user.socialaccount = account user.save() return profile.user
def complete_login(self, request, app, token, email_addresses=[]): client = TwitterAPI(request, app.client_id, app.secret, self.request_token_url) extra_data = client.get_user_info() uid = extra_data['id'] user = User.objects.filter(username=extra_data.get('screen_name')) if user: return user else: user = get_adapter() \ .populate_new_user(username=extra_data.get('screen_name'), name=extra_data.get('name')) user.save() account = SocialAccount(user=user, uid=uid, provider=TwitterProvider.id, extra_data=extra_data) account.save() application = SocialApp.objects.get(secret=app.secret) sample_token = SocialToken.objects.filter(app=application, account=account) if sample_token: token = sample_token[0] else: token = SocialToken(app=application, account=account, token=request.session["oauth_api.twitter.com_access_token"]["oauth_token"], token_secret=request.session["oauth_api.twitter.com_access_token"][ "oauth_token_secret"]) token.save() mail = send_email_confirmation(request=request, user=user, signup=True) return SocialLogin(account=account, token=token, email_addresses=email_addresses)
def register_user(request): try: if request.method == 'POST': req_body = json.loads(request.body.decode()) UserModel = get_user_model() user = UserModel.objects.get( auth0_identifier=req_body['auth0_identifier']) user.first_name = req_body['first_name'] user.last_name = req_body['last_name'] user.username = req_body['username'] user.email = req_body['email'] password = request.user.auth0_identifier.split('.')[1] user.set_password(password) user.save() new_userprofile = UserProfile.objects.create( address=req_body["address"], user=user) new_userprofile.save() # email = req_body['email'] authenticated_user = authenticate( auth0_identifier=req_body['auth0_identifier'], password=password) if authenticated_user is not None: remote_authenticated_user = request.successful_authenticator.authenticate( request) if remote_authenticated_user is not None: management_api_token_endpoint = management_api_oath_endpoint( AUTH0_DOMAIN) management_api_token = json.loads( management_api_token_endpoint) management_api_jwt = management_api_token['access_token'] management_api_user = get_management_api_user( AUTH0_DOMAIN, management_api_jwt, req_body['uid']) token = TokenModel.objects.create( user=remote_authenticated_user[0]) key = token.key extra_data = req_body['extra_data'] extra_data['access_token'] = remote_authenticated_user[1] id_token = json.loads(req_body['id_token']) extra_data['id_token__raw'] = id_token['__raw'] nonce = id_token['nonce'] identities = management_api_user.get('identities')[0] provider = identities.get('provider') # The 'connection' in the auth0 returned result assoc_type = identities.get('connection') exp = id_token['exp'] iat = id_token['iat'] backend_data = backends(request) user_current_backend = authenticated_user.backend #auth0_backend = backend_data['backends']['backends'][1] #openId_backend = backend_data['backends']['backends'][0] #associated_backends = backend_data['backends'].get('associated') # return csrf token for POST form. side effect is have @csrf_protect csrf = req_body[ 'csrf_token'] if 'csrf_token' in req_body and req_body[ 'csrf_token'] else get_token(request) auth0_user_logs = retrieve_user_logs( AUTH0_DOMAIN, management_api_jwt, req_body['uid']) seacft = [ l for l in auth0_user_logs if l['type'] == 'seacft' ] seacft_details = seacft[0].get('details') code = seacft_details.get('code') # ss = [l for l in auth0_user_logs if l['type'] == 'ss'] # ss_details = ss[0].get('details') # transaction = ss_details['body']['transaction'] # associate_user('openid', social_user.uid, authenticated_user, social_user) social_user = remote_authenticated_user[ 0].social_auth.get_or_create( user_id=remote_authenticated_user[0].id, provider=provider, extra_data=extra_data, uid=req_body['auth0_identifier'].replace(".", "|")) # is_association = Association.objects.filter(server_url=AUTH0_OPEN_ID_SERVER_URL, handle=handle).exists() if Association.objects.filter( server_url=AUTH0_OPEN_ID_SERVER_URL, handle=nonce).exists(): user_association = Association.objects.get( server_url=AUTH0_OPEN_ID_SERVER_URL, handle=nonce) else: user_association = Association.objects.create( server_url=AUTH0_OPEN_ID_SERVER_URL, handle=nonce, secret=code, issued=iat, lifetime=exp, assoc_type=assoc_type) social_account = SocialAccount() social_account.user = remote_authenticated_user[0] social_account.uid = req_body['uid'] social_account.provider = provider social_account.extra_data = management_api_user social_account.save() account_email = EmailAddress.objects.get_or_create( user=social_account.user, email=authenticated_user.email, verified=True, primary=True) Nonce.objects.create(server_url=AUTH0_OPEN_ID_SERVER_URL, timestamp=iat, salt=nonce) Code.objects.create(email=account_email[0], code=code, verified=True) social_app = SocialApp.objects.get_or_create( provider=provider, name="Quantum Coasters", secret=SOCIAL_AUTH_AUTH0_SECRET, client_id=AUTH0_CLIENT_ID, key=SOCIAL_AUTH_AUTH0_KEY) time_now = datetime.datetime.now() expires_at = time_now + datetime.timedelta(0, exp) # time = expires_at.time() social_token = SocialToken.objects.create( app_id=social_app[0].id, account_id=social_account.id, token=id_token, token_secret=id_token['__raw'], expires_at=expires_at) # Changed from user to authenticated_user login(request, social_user[0].user, backend='quantumapi.auth0_backend.Auth0') current_user_session = request.session is_session = Session.objects.filter( session_key=current_user_session.session_key).exists() if is_session: session = Session.objects.get( session_key=current_user_session.session_key) else: session = Session.objects.create( user=authenticated_user) # session.save() EmailConfirmation.objects.get_or_create( email_address=account_email[0], key=session.session_key, sent=datetime.datetime.now()) # Turning into Set then back to List to filter out Duplicates (#ToDo-not needed.) social_app_to_list = list(social_app) social_app_data = social_app_to_list[0] auth_user = { "valid": True, "id": user.id, "first_name": user.first_name, "last_name": user.last_name, "email": user.email, "username": user.username, "is_staff": user.is_staff, "auth0_identifier": user.auth0_identifier, "QuantumToken": key, "session": session.session_key, 'csrf': csrf, 'user_social_auth_id': social_user[0].id, 'account_email_id': account_email[0].id, 'management_user': management_api_user, 'social_account_id': social_account.id, 'social_app_id': social_app_data.id, 'social_app_name': social_app_data.name, "social_token_id": social_token.id, 'association_id': user_association.id, 'email_confirmation': True, 'user_profile_id': new_userprofile.id, } data = json.dumps({"DjangoUser": auth_user}) return HttpResponse(data, content_type='application/json') else: error = "Remote authentication failed. Remote Authenticated User was None." data = json.dumps({"Remote Authentication Error": error}) return HttpResponse(data, content_type='application/json') else: error = "Authentication failed. Authenticated User was None." data = json.dumps({"Authentication Error": error}) return HttpResponse(data, content_type='application/json') except Exception as ex: return Response(ex.args, content_type='application/json')
class GitManagerTestCases(TestCase): def setUp(self): call_command('loaddata', 'fixtures/steps.json', verbosity=0) call_command('loaddata', 'fixtures/package_categories_languages.json', verbosity=0) call_command('loaddata', 'fixtures/cookiecutter.json', verbosity=0) self.user = User.objects.create_user('test', '*****@*****.**', 'test') self.workbench_user = WorkbenchUser.objects.get(user=self.user) self.second_user = User.objects.create_user('test2', '*****@*****.**', 'test2') self.git_repo = GitRepository.objects.create( name='Experiment', owner=self.workbench_user, github_url='https://github') schema = DataSchema(name='main') schema.save() self.experiment = Experiment.objects.create(title='Experiment', description='test', owner=self.workbench_user, git_repo=self.git_repo, language_id=1, template_id=2, schema=schema) self.client = Client() self.client.login(username='******', password='******') if self._testMethodName is not 'test_init_github_helper_no_socialtoken': self.set_up_social() def set_up_social(self): self.social_app = SocialApp(provider='GitHub', name='GitHub', client_id='B', secret='A') self.social_app.save() self.social_account = SocialAccount(user=self.user, provider='github', uid='A') self.social_account.save() self.social_token = SocialToken(app=self.social_app, account=self.social_account, token='A', token_secret='B') self.social_token.save() def test_init_github_helper_no_socialtoken(self): github_helper = GitHubHelper args = [self.user, 'test'] self.assertRaises(ValueError, github_helper, *args) @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_init_github_helper(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_init_github_helper_create(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test', create=True) self.assertIsNotNone(github_helper) self.assertEqual(github_helper.github_repository.repo_name, 'newly_created_repo') @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_github_owner(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) self.assertEqual(github_helper.owner, 'test') @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_init_github_helper(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) self.assertEqual(github_helper.get_clone_url(), 'https://A@clone-url') @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_github_list_folder(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) self.assertEqual(github_helper.list_files_in_folder('test1'), GithubMockRepo.TEST1_LIST) @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_github_list_folder_with_slash(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) self.assertEqual(github_helper.list_files_in_folder('/test1'), GithubMockRepo.TEST1_LIST) @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_github_list_folder_empty(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper) self.assertEqual(github_helper.list_files_in_folder(), GithubMockRepo.TEST2_LIST) @patch('git_manager.helpers.github_helper.GitHubHelper._get_github_object') def test_view_file_in_repo(self, mock_github): mock_github.return_value = GithubMock() github_helper = GitHubHelper(self.user, 'test') self.assertIsNotNone(github_helper)