← Back to branch summary

~ubuntu-branches/debian/sid/social-auth-core/sid

« back to all changes in this revision

Viewing changes to social_core/tests/actions/actions.py

  • Committer: Package Import Robot
  • Author(s): Andre Bianchi
  • Date: 2018-02-22 19:49:12 UTC
  • Revision ID: package-import@ubuntu.com-20180222194912-4lqv8mlhnqc4ncd3
Tags: upstream-1.7.0
Import upstream version 1.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
social_core/tests/actions/actions.py
 
1
import json
 
2
import requests
 
3
import unittest2 as unittest
 
4
 
 
5
from httpretty import HTTPretty
 
6
 
 
7
from six.moves.urllib_parse import urlparse
 
8
 
 
9
from ...utils import parse_qs, module_member
 
10
from ...actions import do_auth, do_complete
 
11
from ..models import TestStorage, User, TestUserSocialAuth, TestNonce, \
 
12
                     TestAssociation
 
13
from ..strategy import TestStrategy
 
14
 
 
15
 
 
16
class BaseActionTest(unittest.TestCase):
 
17
    user_data_url = 'https://api.github.com/user'
 
18
    login_redirect_url = '/success'
 
19
    expected_username = 'foobar'
 
20
    access_token_body = json.dumps({
 
21
        'access_token': 'foobar',
 
22
        'token_type': 'bearer'
 
23
    })
 
24
    user_data_body = json.dumps({
 
25
        'login': 'foobar',
 
26
        'id': 1,
 
27
        'avatar_url': 'https://github.com/images/error/foobar_happy.gif',
 
28
        'gravatar_id': 'somehexcode',
 
29
        'url': 'https://api.github.com/users/foobar',
 
30
        'name': 'monalisa foobar',
 
31
        'company': 'GitHub',
 
32
        'blog': 'https://github.com/blog',
 
33
        'location': 'San Francisco',
 
34
        'email': 'foo@bar.com',
 
35
        'hireable': False,
 
36
        'bio': 'There once was...',
 
37
        'public_repos': 2,
 
38
        'public_gists': 1,
 
39
        'followers': 20,
 
40
        'following': 0,
 
41
        'html_url': 'https://github.com/foobar',
 
42
        'created_at': '2008-01-14T04:33:35Z',
 
43
        'type': 'User',
 
44
        'total_private_repos': 100,
 
45
        'owned_private_repos': 100,
 
46
        'private_gists': 81,
 
47
        'disk_usage': 10000,
 
48
        'collaborators': 8,
 
49
        'plan': {
 
50
            'name': 'Medium',
 
51
            'space': 400,
 
52
            'collaborators': 10,
 
53
            'private_repos': 20
 
54
        }
 
55
    })
 
56
 
 
57
    def __init__(self, *args, **kwargs):
 
58
        self.strategy = None
 
59
        super(BaseActionTest, self).__init__(*args, **kwargs)
 
60
 
 
61
    def setUp(self):
 
62
        HTTPretty.enable()
 
63
        User.reset_cache()
 
64
        TestUserSocialAuth.reset_cache()
 
65
        TestNonce.reset_cache()
 
66
        TestAssociation.reset_cache()
 
67
        Backend = module_member('social_core.backends.github.GithubOAuth2')
 
68
        self.strategy = self.strategy or TestStrategy(TestStorage)
 
69
        self.backend = Backend(self.strategy, redirect_uri='/complete/github')
 
70
        self.user = None
 
71
 
 
72
    def tearDown(self):
 
73
        self.backend = None
 
74
        self.strategy = None
 
75
        self.user = None
 
76
        User.reset_cache()
 
77
        User.set_active(True)
 
78
        TestUserSocialAuth.reset_cache()
 
79
        TestNonce.reset_cache()
 
80
        TestAssociation.reset_cache()
 
81
        HTTPretty.disable()
 
82
 
 
83
    def do_login(self, after_complete_checks=True, user_data_body=None,
 
84
                 expected_username=None):
 
85
        self.strategy.set_settings({
 
86
            'SOCIAL_AUTH_GITHUB_KEY': 'a-key',
 
87
            'SOCIAL_AUTH_GITHUB_SECRET': 'a-secret-key',
 
88
            'SOCIAL_AUTH_LOGIN_REDIRECT_URL': self.login_redirect_url,
 
89
            'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
 
90
                'social_core.backends.github.GithubOAuth2',
 
91
            )
 
92
        })
 
93
        start_url = do_auth(self.backend).url
 
94
        target_url = self.strategy.build_absolute_uri(
 
95
            '/complete/github/?code=foobar'
 
96
        )
 
97
 
 
98
        start_query = parse_qs(urlparse(start_url).query)
 
99
        location_url = target_url + ('&' if '?' in target_url else '?') + \
 
100
                       'state=' + start_query['state']
 
101
        location_query = parse_qs(urlparse(location_url).query)
 
102
 
 
103
        HTTPretty.register_uri(HTTPretty.GET, start_url, status=301,
 
104
                               location=location_url)
 
105
        HTTPretty.register_uri(HTTPretty.GET, location_url, status=200,
 
106
                               body='foobar')
 
107
 
 
108
        response = requests.get(start_url)
 
109
        self.assertEqual(response.url, location_url)
 
110
        self.assertEqual(response.text, 'foobar')
 
111
 
 
112
        HTTPretty.register_uri(HTTPretty.POST,
 
113
                               uri=self.backend.ACCESS_TOKEN_URL,
 
114
                               status=200,
 
115
                               body=self.access_token_body or '',
 
116
                               content_type='text/json')
 
117
 
 
118
        if self.user_data_url:
 
119
            user_data_body = user_data_body or self.user_data_body or ''
 
120
            HTTPretty.register_uri(HTTPretty.GET, self.user_data_url,
 
121
                                   body=user_data_body,
 
122
                                   content_type='text/json')
 
123
        self.strategy.set_request_data(location_query, self.backend)
 
124
 
 
125
        def _login(backend, user, social_user):
 
126
            backend.strategy.session_set('username', user.username)
 
127
 
 
128
        redirect = do_complete(self.backend, user=self.user, login=_login)
 
129
 
 
130
        if after_complete_checks:
 
131
            self.assertEqual(self.strategy.session_get('username'),
 
132
                             expected_username or self.expected_username)
 
133
            self.assertEqual(redirect.url, self.login_redirect_url)
 
134
        return redirect
 
135
 
 
136
    def do_login_with_partial_pipeline(self, before_complete=None):
 
137
        self.strategy.set_settings({
 
138
            'SOCIAL_AUTH_GITHUB_KEY': 'a-key',
 
139
            'SOCIAL_AUTH_GITHUB_SECRET': 'a-secret-key',
 
140
            'SOCIAL_AUTH_LOGIN_REDIRECT_URL': self.login_redirect_url,
 
141
            'SOCIAL_AUTH_AUTHENTICATION_BACKENDS': (
 
142
                'social_core.backends.github.GithubOAuth2',
 
143
            ),
 
144
            'SOCIAL_AUTH_PIPELINE': (
 
145
                'social_core.pipeline.social_auth.social_details',
 
146
                'social_core.pipeline.social_auth.social_uid',
 
147
                'social_core.pipeline.social_auth.auth_allowed',
 
148
                'social_core.tests.pipeline.ask_for_password',
 
149
                'social_core.pipeline.social_auth.social_user',
 
150
                'social_core.pipeline.user.get_username',
 
151
                'social_core.pipeline.user.create_user',
 
152
                'social_core.pipeline.social_auth.associate_user',
 
153
                'social_core.pipeline.social_auth.load_extra_data',
 
154
                'social_core.tests.pipeline.set_password',
 
155
                'social_core.pipeline.user.user_details'
 
156
            )
 
157
        })
 
158
        start_url = do_auth(self.backend).url
 
159
        target_url = self.strategy.build_absolute_uri(
 
160
            '/complete/github/?code=foobar'
 
161
        )
 
162
 
 
163
        start_query = parse_qs(urlparse(start_url).query)
 
164
        location_url = target_url + ('&' if '?' in target_url else '?') + \
 
165
                       'state=' + start_query['state']
 
166
        location_query = parse_qs(urlparse(location_url).query)
 
167
 
 
168
        HTTPretty.register_uri(HTTPretty.GET, start_url, status=301,
 
169
                               location=location_url)
 
170
        HTTPretty.register_uri(HTTPretty.GET, location_url, status=200,
 
171
                               body='foobar')
 
172
 
 
173
        response = requests.get(start_url)
 
174
        self.assertEqual(response.url, location_url)
 
175
        self.assertEqual(response.text, 'foobar')
 
176
 
 
177
        HTTPretty.register_uri(HTTPretty.GET,
 
178
                               uri=self.backend.ACCESS_TOKEN_URL,
 
179
                               status=200,
 
180
                               body=self.access_token_body or '',
 
181
                               content_type='text/json')
 
182
 
 
183
        if self.user_data_url:
 
184
            HTTPretty.register_uri(HTTPretty.GET, self.user_data_url,
 
185
                                   body=self.user_data_body or '',
 
186
                                   content_type='text/json')
 
187
        self.strategy.set_request_data(location_query, self.backend)
 
188
 
 
189
        def _login(backend, user, social_user):
 
190
            backend.strategy.session_set('username', user.username)
 
191
 
 
192
        redirect = do_complete(self.backend, user=self.user, login=_login)
 
193
        url = self.strategy.build_absolute_uri('/password')
 
194
        self.assertEqual(redirect.url, url)
 
195
        HTTPretty.register_uri(HTTPretty.GET, redirect.url, status=200,
 
196
                               body='foobar')
 
197
        HTTPretty.register_uri(HTTPretty.POST, redirect.url, status=200)
 
198
 
 
199
        password = 'foobar'
 
200
        requests.get(url)
 
201
        requests.post(url, data={'password': password})
 
202
        data = parse_qs(HTTPretty.last_request.body)
 
203
        self.assertEqual(data['password'], password)
 
204
        self.strategy.session_set('password', data['password'])
 
205
 
 
206
        if before_complete:
 
207
            before_complete()
 
208
        redirect = do_complete(self.backend, user=self.user, login=_login)
 
209
        self.assertEqual(self.strategy.session_get('username'),
 
210
                         self.expected_username)
 
211
        self.assertEqual(redirect.url, self.login_redirect_url)