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)
