-
Notifications
You must be signed in to change notification settings - Fork 2
/
Copy pathtests.py
149 lines (113 loc) · 5.17 KB
/
tests.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import json
from io import BytesIO
from unittest import TestCase
try:
from urllib2 import HTTPError, urlopen
from urllib import urlencode
except ImportError:
from urllib.request import urlopen
from urllib.parse import urlencode, parse_qsl
from urllib.error import HTTPError
import stepford
NUM_TEST_USERS = 3
CLIENT_ID = '290035784470436'
CLIENT_SECRET = '96b81e5dec11ef0081a8b02fa1054b66'
CLIENT_B_ID = '570048633057536'
CLIENT_B_SECRET = '97699b4b2deb8959131c861dc653f81e'
class TestStepford(TestCase):
@classmethod
def setUpClass(cls):
cls.access_token = stepford.app_token(CLIENT_ID, CLIENT_SECRET)
cls.users = []
for _ in range(NUM_TEST_USERS):
cls.users.append(stepford.create(CLIENT_ID, cls.access_token))
@classmethod
def tearDownClass(cls):
for user in cls.users:
stepford.delete(user['id'], cls.access_token)
def test_get(self):
self.assertEqual(len(self.users), NUM_TEST_USERS)
user_ids = set(map(lambda u: u['id'], self.users))
fetched_user_ids = set(map(lambda u: u['id'], stepford.get(
CLIENT_ID, self.access_token)))
self.assertEqual(len(user_ids - fetched_user_ids), 0)
def test_create_delete_success(self):
user = stepford.create(CLIENT_ID, self.access_token)
self.assertTrue(user['id'] in map(lambda u: u['id'], stepford.get(
CLIENT_ID, self.access_token)))
self.assertTrue(stepford.delete(user['id'], self.access_token))
self.assertTrue(user['id'] not in map(lambda u: u['id'], stepford.get(
CLIENT_ID, self.access_token)))
try:
stepford.delete(user['id'], self.access_token)
except stepford.FacebookError as e:
self.assertEqual(e.api_code,
stepford.API_EC_UNABLE_TO_ACCESS_APPLICATION)
def test_connect_success(self):
stepford.connect(*self.users)
for user in self.users:
# given user should be friends with everyone
resp = urlopen('{}/me/friends?{}'.format(stepford._URIROOT,
urlencode({'access_token': user['access_token']})))
data = json.loads(resp.read().decode())
lusers = set(map(lambda u: u['id'], self.users)) - set(
[user['id']])
rusers = set(map(lambda u: u['id'], stepford.get(CLIENT_ID,
self.access_token)))
self.assertEqual(len(lusers - rusers), 0)
# TODO: reset connections if any other tests end up depending on clean
# user state.
def test_connect_single_user_error(self):
self.assertRaises(ValueError, stepford.connect, (self.users[0],))
def test_update_success(self):
def _getname(token):
resp = urlopen('{}/me?{}'.format(stepford._URIROOT, urlencode({
'access_token': user['access_token']})))
return json.loads(resp.read().decode())['name']
user = self.users[0]
stepford.update(user['id'], self.access_token, name='foo',
pwd='flyingcircus')
# because of the password change, we have to get the full list of app
# test users (ew) in order to get the updated access_token or the user
# we're currently working with.
user['access_token'] = list(filter(lambda u: u['id'] == user['id'],
stepford.get(CLIENT_ID, self.access_token)))[0]['access_token']
self.assertEqual(_getname(user['access_token']), 'foo')
def test_update_error(self):
try:
stepford.update('123', self.access_token, name='WRONG')
except stepford.FacebookError as e:
self.assertEqual(e.api_code,
stepford.API_EC_UNABLE_TO_ACCESS_APPLICATION)
def test_install_success(self):
b_token = stepford.app_token(CLIENT_B_ID, CLIENT_B_SECRET)
user = self.users[0]
self.assertTrue(stepford.install(
user['id'], b_token, CLIENT_ID, self.access_token,
scope='read_stream'))
resp = urlopen('{}/{}/ownerapps?{}'.format(stepford._URIROOT,
user['id'], urlencode({
'access_token': b_token,
})))
self.assertTrue('stepford_b' in map(lambda app: app['name'],
json.loads(resp.read().decode())['data']))
try:
# can't delete user account while other apps are still installed
stepford.delete(user['id'], self.access_token)
except stepford.FacebookError as e:
self.assertEqual(e.api_code,
stepford.API_EC_TEST_ACCOUNTS_CANT_DELETE)
self.assertTrue(stepford.uninstall(user['id'], CLIENT_B_ID, b_token))
def test_something_bad_happened(self):
urlopen_ = stepford.urlopen
def _raise(url, *args, **kwargs):
raise HTTPError(url, 500, 'err..', {},
BytesIO('something bad happened'))
stepford.urlopen = _raise
try:
token = stepford.app_token(CLIENT_ID, CLIENT_SECRET)
except stepford.FacebookError as e:
stepford.urlopen = urlopen_
self.assertEqual(e.api_code, None)
self.assertEqual(e.type, None)
self.assertEqual(e.msg, 'Unhandled error')