def test_find_match_not_matched(self):
key1 = "chr1:154000-230000"
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def test_find_match_not_matched(self):
key1 = 'chr1:154000-230000'
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def test(serial):
m = Mocker()
proj = Project.create()
log = m.replace("editxt.project.log", passthrough=False)
nsdat = m.replace(NSData, passthrough=False)
nspls = m.replace(NSPropertyListSerialization, passthrough=False)
create_document_view_with_state = m.method(Project.create_document_view_with_state)
create_document_view = m.method(Project.create_document_view)
proj._documents = docs = m.mock(KVOList)
if "path" in serial:
data = nsdat.dataWithContentsOfFile_(serial["path"]) >> m.mock()
serial_, format, error = nspls. \
propertyListFromData_mutabilityOption_format_errorDescription_( \
data, NSPropertyListImmutable, None, None) >> ({}, m.mock(), None)
else:
serial_ = serial
docs_ = serial_.get("documents", [])
for item in docs_:
create_document_view_with_state(item)
if item == "doc_not_found":
m.throw(Exception("document not found"))
log.warn("cannot open document: %r" % item)
#proj._is_dirty = True
bool(docs); m.result(bool(docs_))
if not docs_:
create_document_view()
#proj._is_dirty = True
with m:
proj.deserialize(serial)
if "path" in serial:
eq_(proj.path, serial["path"])
assert "name" not in serial
else:
eq_(proj.name, serial.get("name", const.UNTITLED_PROJECT_NAME))
eq_(proj.expanded, serial.get("expanded", True))
def test_order_not_filled():
order = Order("item #1", 1)
mocker = Mocker()
inventory = mocker.mock()
inventory.remove("item #1", 1)
mocker.throw(QuantityError)
mocker.replay()
order.fill(inventory)
mocker.verify()
assert not order.filled
def test_selenium_driver_raises_on_start_test_when_selenium_cant_start():
mocker = Mocker()
context = Context(Settings())
selenium_mock = mocker.mock()
selenium_mock.start()
mocker.throw(DriverError("invalid usage"))
with mocker:
driver = SeleniumDriver(context, selenium=selenium_mock)
assert_raises(DriverError, driver.start_test, url="http://localhost", \
exc_pattern=re.compile(r"Error when starting selenium. Is it running ?"))
def test_wait_for_disappear_works_even_when_is_visible_raises():
mocker = Mocker()
context = Context(Settings())
selenium_mock = mocker.mock()
selenium_mock.is_element_present('some element')
mocker.count(min=1, max=None)
mocker.result(True)
selenium_mock.is_visible('some element')
mocker.throw(Exception("ERROR: Element some element not found"))
with mocker:
driver = SeleniumDriver(context, selenium=selenium_mock)
driver.wait_for_element_to_disappear("some element", 1)
def test_shared_exon(self):
mocker = Mocker()
self.model = mocker.mock()
self.model.blockStarts
mocker.result([100, 400, 700])
mocker.count(2, None)
self.model.blockSizes
mocker.result([100, 100, 100])
mocker.count(1, None)
self.model.chrom
mocker.result('chr1')
mocker.count(2, None)
self.model.start
mocker.result(0)
mocker.count(1, None)
self.junctions1 = mocker.mock()
self.junctions2 = mocker.mock()
self.junc1 = [400]
self.junc2 = [700]
juncKey = 'chr1:200'
self.junctions1[juncKey]
mocker.result(self.junc1)
self.junctions2[juncKey]
mocker.result(self.junc2)
juncKey = 'chr1:500'
self.junctions1[juncKey]
mocker.throw(KeyError)
juncKey = 'chr1:800'
self.junctions1[juncKey]
mocker.throw(KeyError)
mocker.replay()
self.sharedExons = {}
jc.scanJunctions(self.model, self.junctions1, self.junctions2,
self.sharedExons)
for j in self.sharedExons:
self.assertEqual(self.sharedExons[j], [400])
self.assertEqual(j, 'chr1:200')
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
mi = m.mock(ak.NSMenuItem)
tv = m.mock(ak.NSTextView)
tc = m.mock()
tcc = CommandManager("<history>")
cmds = m.replace(tcc, "commands")
cmds.get(mi.tag() >> 42) >> (tc if c.has_command else None)
if c.has_command:
tc(tv, None)
if c.error:
m.throw(Exception)
lg.exception("%s.execute failed", ANY)
with m:
tcc.do_menu_command(tv, mi)
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
mi = m.mock(ak.NSMenuItem)
tv = m.mock(ak.NSTextView)
tc = m.mock()
tcc = TextCommandController("<history>")
cmds = m.replace(tcc, 'commands')
cmds.get(mi.tag() >> 42) >> (tc if c.has_command else None)
if c.has_command:
tc(tv, mi, None)
if c.error:
m.throw(Exception)
lg.error("%s.execute failed", ANY, exc_info=True)
with m:
tcc.do_textview_command(tv, mi)
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log", passthrough=False)
mi = m.mock(NSMenuItem)
tv = m.mock(NSTextView)
tc = m.mock(TextCommand)
tcc = TextCommandController(None)
cmds = m.replace(tcc.commands)
cmd = cmds.get(mi.tag() >> 42) >> (tc if c.has_command else None)
if c.has_command:
cmd.execute(tv, mi)
if c.error:
m.throw(Exception)
lg.error("%s.execute failed", ANY, exc_info=True)
with m:
tcc.do_textview_command(tv, mi)
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
mi = m.mock(ak.NSMenuItem)
tv = m.mock(ak.NSTextView)
tc = m.mock()
tcc = TextCommandController("<history>")
cmds = m.replace(tcc, 'commands')
cmds.get(mi.tag() >> 42) >> (tc if c.has_command else None)
if c.has_command:
tc(tv, mi, None)
if c.error:
m.throw(Exception)
lg.error("%s.execute failed", ANY, exc_info=True)
with m:
tcc.do_textview_command(tv, mi)
def test_shared_exon(self):
mocker = Mocker()
self.model = mocker.mock()
self.model.blockStarts
mocker.result([100, 400, 700])
mocker.count(2, None)
self.model.blockSizes
mocker.result([100, 100, 100])
mocker.count(1, None)
self.model.chrom
mocker.result("chr1")
mocker.count(2, None)
self.model.start
mocker.result(0)
mocker.count(1, None)
self.junctions1 = mocker.mock()
self.junctions2 = mocker.mock()
self.junc1 = [400]
self.junc2 = [700]
juncKey = "chr1:200"
self.junctions1[juncKey]
mocker.result(self.junc1)
self.junctions2[juncKey]
mocker.result(self.junc2)
juncKey = "chr1:500"
self.junctions1[juncKey]
mocker.throw(KeyError)
juncKey = "chr1:800"
self.junctions1[juncKey]
mocker.throw(KeyError)
mocker.replay()
self.sharedExons = {}
jc.scanJunctions(self.model, self.junctions1, self.junctions2, self.sharedExons)
for j in self.sharedExons:
self.assertEqual(self.sharedExons[j], [400])
self.assertEqual(j, "chr1:200")
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
tv = m.mock(ak.NSTextView)
tcc = TextCommandController("<history>")
sel = "<selector>"
callback = m.mock()
handlers = m.replace(tcc, 'input_handlers')
cmd = handlers.get(sel) >> (callback if c.has_selector else None)
if c.has_selector:
callback(tv, None, None)
if c.error:
m.throw(Exception)
lg.error("%s failed", callback, exc_info=True)
with m:
result = tcc.do_textview_command_by_selector(tv, sel)
eq_(result, c.result)
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
tv = m.mock(ak.NSTextView)
tcc = TextCommandController("<history>")
sel = "<selector>"
callback = m.mock()
handlers = m.replace(tcc, 'input_handlers')
cmd = handlers.get(sel) >> (callback if c.has_selector else None)
if c.has_selector:
callback(tv, None, None)
if c.error:
m.throw(Exception)
lg.error("%s failed", callback, exc_info=True)
with m:
result = tcc.do_textview_command_by_selector(tv, sel)
eq_(result, c.result)
def test(c):
m = Mocker()
lg = m.replace("editxt.textcommand.log")
tv = m.mock(ak.NSTextView)
tcc = CommandManager("<history>")
sel = "<selector>"
callback = m.mock()
handlers = m.replace(tcc, "input_handlers")
cmd = handlers.get(sel) >> (callback if c.has_selector else None)
if c.has_selector:
callback(tv, None)
if c.error:
m.throw(Exception)
lg.exception("%s failed", callback)
with m:
result = tcc.do_command(tv, sel)
eq_(result, c.result)
def test_is_element_visible_with_element_removal_while_executing(self):
from selenium.common.exceptions import StaleElementReferenceException
mocker = Mocker()
context = Context(Settings())
browser_mock = mocker.mock()
xpath = '//div'
browser_mock.find_by_xpath(xpath)
element_mock = mocker.mock()
mocker.result(element_mock)
element_mock.visible
mocker.throw(StaleElementReferenceException)
with mocker:
driver = SplinterDriver(context, browser=browser_mock)
is_visible = driver.is_element_visible(xpath)
self.assertEqual(is_visible, False)
def test_find_match_match_not_match(self):
key1 = ["chr1:154000-230000", "chr1:155000-230000"]
key2 = ["chr1:154000-230000"]
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result(key1)
container1[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container1[key1[1]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[1]]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [key1[0]])
self.assertEqual(self.diff.keys(), [key1[1]])
mocker.restore()
mocker.verify()
def test_find_match_match_not_match(self):
key1 = ['chr1:154000-230000', 'chr1:155000-230000']
key2 = ['chr1:154000-230000']
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result(key1)
container1[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container1[key1[1]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[1]]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [key1[0]])
self.assertEqual(self.diff.keys(), [key1[1]])
mocker.restore()
mocker.verify()
def test(serial):
m = Mocker()
proj = Project.create()
log = m.replace(mod, 'log')
nsdat = m.replace(fn, 'NSData')
nspls = m.replace(fn, 'NSPropertyListSerialization')
create_document_view_with_state = m.method(
Project.create_document_view_with_state)
create_document_view = m.method(Project.create_document_view)
proj._documents = docs = m.mock(KVOList)
if "path" in serial:
data = nsdat.dataWithContentsOfFile_(serial["path"]) >> m.mock()
serial_, format, error = nspls. \
propertyListFromData_mutabilityOption_format_errorDescription_( \
data, NSPropertyListImmutable, None, None) >> ({}, m.mock(), None)
else:
serial_ = serial
docs_ = serial_.get("documents", [])
for item in docs_:
create_document_view_with_state(item)
if item == "doc_not_found":
m.throw(Exception("document not found"))
log.warn("cannot open document: %r" % item)
#proj._is_dirty = True
bool(docs)
m.result(bool(docs_))
if not docs_:
create_document_view()
#proj._is_dirty = True
with m:
proj.deserialize(serial)
if "path" in serial:
eq_(proj.path, serial["path"])
assert "name" not in serial
else:
eq_(proj.name, serial.get("name", const.UNTITLED_PROJECT_NAME))
eq_(proj.expanded, serial.get("expanded", True))
def test_create_database_terminates_the_instance_if_it_fails_to_create_the_database_and_save_instance_with_error_state(self):
exc_msg = u"I've failed to create your database, sorry! :("
mocker = Mocker()
c_database = mocker.replace("mysqlapi.api.models.DatabaseManager.create_database")
c_database()
mocker.throw(Exception(exc_msg))
mocker.replay()
instance = Instance(
ec2_id="i-00009",
name="home",
host="unknown.host",
state="running",
)
ec2_client = mocks.FakeEC2Client()
try:
t = create_database(instance, ec2_client)
t.join()
self.assertIn("terminate instance home", ec2_client.actions)
self.assertIsNotNone(instance.pk)
self.assertEqual("error", instance.state)
self.assertEqual(exc_msg, instance.reason)
finally:
instance.delete()
mocker.verify()
class OAuthTwitterTest(TestCase):
urls = 'django_oauth_twitter.test_urls'
def setUp(self):
self.mocker = Mocker()
self.password = User.objects.create_user('password', '', 'password')
self.twitter = User.objects.create_user('twitter', '', 'twitter')
json = '{"screen_name": "twitter"}'
self.twitter_user = TwitterUser.objects.create(user=self.twitter,
twitter_id=1,
userinfo_json=json)
# Replace TEMPLATE lookups
self.old_template_dirs = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
'templates'),)
self.old_template_loaders = settings.TEMPLATE_LOADERS
settings.TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.load_template_source',
)
django.template.loader.template_source_loaders = None
# Replace LOGIN_URL and LOGIN_REDIRECT_URL
self.old_login_url = settings.LOGIN_URL
settings.LOGIN_URL = '/login/'
self.old_login_redirect_url = settings.LOGIN_REDIRECT_URL
settings.LOGIN_REDIRECT_URL = '/home/'
self.old_login_redirect_urlname = getattr(settings,
'LOGIN_REDIRECT_URLNAME',
None)
settings.LOGIN_REDIRECT_URLNAME = None
def tearDown(self):
# Restore TEMPLATE lookups
settings.TEMPLATE_DIRS = self.old_template_dirs
settings.TEMPLATE_LOADERS = self.old_template_loaders
django.template.loader.template_source_loaders = None
# Restore LOGIN_URL and LOGIN_REDIRECT_URL
settings.LOGIN_URL = self.old_login_url
settings.LOGIN_REDIRECT_URL = self.old_login_redirect_url
settings.LOGIN_REDIRECT_URLNAME = self.old_login_redirect_urlname
def test_association_anonymous(self):
import django
# Ensure we need a login.
url = reverse('twitter_associate')
login_url = settings.LOGIN_URL
if django.VERSION < (1, 2):
login_url = self.old_login_url
response = self.client.get(url)
self.assertEqual(
response['Location'],
'http://testserver%s?next=%s' % (login_url,
quote('http://testserver' + url))
)
def test_association_user_add(self):
# User adds association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get, user=self.password)
self.assertTrue(self.client.login(username=self.password.username,
password=self.password.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{"id": 2}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key},
follow=True)
self.assertEqual(
response.redirect_chain,
[('http://testserver/twitter/associate/', 302)]
)
self.assertEqual(response.status_code, 200)
def test_association_user_remove(self):
# User removes association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get, user=self.password)
self.assertTrue(self.client.login(username=self.password.username,
password=self.password.username))
response = self.client.post(reverse('twitter_associate'),
{'action': 'remove',
'twitter_id': '1'})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get, user=self.password)
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get, user=self.password)
def test_association_associated_add(self):
# Associated adds association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key})
self.assertEqual(response['Location'],
'http://testserver/twitter/associate/'
'?user=twitter&error=user_already_linked')
def test_association_associated_remove(self):
Api = self.mocker.replace(TwitterApi)
userinfo = self.mocker.mock()
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# Associated removes association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(self.client.login(username=self.twitter.username,
password=self.twitter.username))
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertTrue(TwitterUser.objects.get(user=self.twitter))
response = self.client.post(reverse('twitter_associate'),
{'action': 'remove',
'twitter_id': '1'})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get, user=self.twitter)
def test_association_user_revoked(self):
# User visits associate after revoking their Twitter credentials.
self.assertTrue(self.twitter.twitter)
self.assertTrue(self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api(ANY).GetUserInfo()
self.mocker.throw(HTTPError('url', 401, '', {}, None))
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
def test_callback(self):
# User goes directly to the callback page.
response = self.client.get(reverse(oauthtwitter.callback))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User goes directly to the callback page. but tampers with oauth_token
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': 'bad'})
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User comes in through Twitter OAuth, but tampers with oauth_token
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
request.GET
self.mocker.result({'oauth_token': 'bad'})
request.session
self.mocker.result({})
self.mocker.count(1, None)
request.twitter_request_token
self.mocker.result(TOKEN)
# New user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api = self.mocker.replace(TwitterApi)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(AnonymousUser())
userinfo = self.mocker.mock()
cui = self.mocker.replace(cached_user_info)
cui(request, TOKEN)
self.mocker.result(userinfo)
o._authenticate(userinfo=userinfo)
self.mocker.result(None)
# Existing user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(User.objects.get(username='******'))
self.mocker.count(1, 2)
cui(request, TOKEN)
self.mocker.result(userinfo)
self.mocker.count(1, 2)
userinfo.id
self.mocker.result(3)
userinfo.AsJsonString()
self.mocker.result('{}')
with self.mocker:
response = o.callback(request)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o.callback(request)
self.assertEqual(response['Location'],
reverse(oauthtwitter.register))
response = o.callback(request)
self.assertEqual(response['Location'], '/home/')
def test_signin(self):
response = self.client.get(reverse('twitter_signin'))
prefix = 'http://twitter.com/oauth/authenticate?'
self.assertTrue(response['Location'].startswith(prefix),
response['Location'])
def test_register(self):
# User goes directly to the register page.
response = self.client.get(reverse(oauthtwitter.register))
self.assertTrue(response['Location'], settings.LOGIN_URL)
# User is logged in
self.assertTrue(self.client.login(username='******',
password='******'))
response = self.client.get(reverse(oauthtwitter.register))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_REDIRECT_URL)
# New user comes in through Twitter
request = self.mocker.mock()
request.user
self.mocker.result(AnonymousUser())
self.mocker.count(1, None)
RC = self.mocker.replace('django.template.RequestContext')
RC(ANY)
self.mocker.result({})
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.screen_name
self.mocker.result('unknown')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('GET')
# New user posts form through Twitter
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo.id
self.mocker.result(2)
userinfo.screen_name
self.mocker.result('unknown')
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('POST')
request.POST
self.mocker.result({'username': '******'})
o = self.mocker.patch(oauthtwitter)
o._login_and_redirect(request=request, user=ANY)
self.mocker.result('New user')
with self.mocker:
response = oauthtwitter.register(request)
self.assertEqual(response.status_code, 200)
response = o.register(request)
self.assertEqual(response, 'New user')
self.assertTrue(User.objects.get(username='******'))
def test_authenticate(self):
# Associated Twitter user
twitter = self.mocker.mock()
twitter.id
self.mocker.result(1)
# Unknown Twitter uesr
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
with self.mocker:
self.assertEqual(oauthtwitter._authenticate(twitter),
User.objects.get(username="******"))
self.assertEqual(oauthtwitter._authenticate(unknown), None)
def test_create_user(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
request.user.is_anonymous()
self.mocker.result(False)
o._login_and_redirect(request=request, user=None)
self.mocker.result('Logged in')
# Anonymous user with new User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
unknown.screen_name
self.mocker.result("unknown")
unknown.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(unknown)
o._login_and_redirect(request=request,
user=MATCH(lambda x: isinstance(x, User)))
self.mocker.result('New user')
# Anonymous user with existing User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
twitter = self.mocker.mock()
twitter.screen_name
self.mocker.result("twitter")
request.twitter_userinfo
self.mocker.result(twitter)
with self.mocker:
response = o._create_user(request)
self.assertEqual(response, 'Logged in')
response = o._create_user(request)
self.assertEqual(response, 'New user')
response = o._create_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_login_and_redirect(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
twitter = User.objects.get(username='******')
request.user
self.mocker.result(twitter)
# No User to log in
True
# Login a Twitter user
o._login(request, twitter)
request.user
self.mocker.result(AnonymousUser())
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.session
self.mocker.result({SUCCESS_URL_KEY: (TOKEN, '/home/')})
request.twitter_request_token
self.mocker.result(TOKEN)
with self.mocker:
response = o._login_and_redirect(request, user=True)
self.assertEqual(response['Location'], settings.LOGIN_REDIRECT_URL)
response = o._login_and_redirect(request, user=None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o._login_and_redirect(request, user=twitter)
self.assertEqual(response['Location'], '/home/')
self.assertEqual(str(twitter.twitter.access_token), str(TOKEN))
self.assertEqual(twitter.twitter.userinfo_json, '{}')
def test_on_new_user(self):
# With auto_create_user
request = self.mocker.mock()
a = self.mocker.patch(OAuthTwitter(auto_create_user=True))
a._create_user(request)
self.mocker.result('auto_create')
# Without
b = self.mocker.patch(oauthtwitter)
with self.mocker:
response = a._on_new_user(request)
self.assertEqual(response, 'auto_create')
response = b._on_new_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_redirect_to_login(self):
response = oauthtwitter._redirect_to_login(None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
class OAuthTwitterTest(TestCase):
urls = 'django_oauth_twitter.test_urls'
def setUp(self):
self.mocker = Mocker()
self.password = User.objects.create_user('password', '', 'password')
self.twitter = User.objects.create_user('twitter', '', 'twitter')
json = '{"screen_name": "twitter"}'
self.twitter_user = TwitterUser.objects.create(user=self.twitter,
twitter_id=1,
userinfo_json=json)
# Replace TEMPLATE lookups
self.old_template_dirs = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
'templates'), )
self.old_template_loaders = settings.TEMPLATE_LOADERS
settings.TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.load_template_source', )
django.template.loader.template_source_loaders = None
# Replace LOGIN_URL and LOGIN_REDIRECT_URL
self.old_login_url = settings.LOGIN_URL
settings.LOGIN_URL = '/login/'
self.old_login_redirect_url = settings.LOGIN_REDIRECT_URL
settings.LOGIN_REDIRECT_URL = '/home/'
self.old_login_redirect_urlname = getattr(settings,
'LOGIN_REDIRECT_URLNAME',
None)
settings.LOGIN_REDIRECT_URLNAME = None
def tearDown(self):
# Restore TEMPLATE lookups
settings.TEMPLATE_DIRS = self.old_template_dirs
settings.TEMPLATE_LOADERS = self.old_template_loaders
django.template.loader.template_source_loaders = None
# Restore LOGIN_URL and LOGIN_REDIRECT_URL
settings.LOGIN_URL = self.old_login_url
settings.LOGIN_REDIRECT_URL = self.old_login_redirect_url
settings.LOGIN_REDIRECT_URLNAME = self.old_login_redirect_urlname
def test_association_anonymous(self):
import django
# Ensure we need a login.
url = reverse('twitter_associate')
login_url = settings.LOGIN_URL
if django.VERSION < (1, 2):
login_url = self.old_login_url
response = self.client.get(url)
self.assertEqual(
response['Location'], 'http://testserver%s?next=%s' %
(login_url, quote('http://testserver' + url)))
def test_association_user_add(self):
# User adds association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
self.assertTrue(
self.client.login(username=self.password.username,
password=self.password.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{"id": 2}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key},
follow=True)
self.assertEqual(response.redirect_chain,
[('http://testserver/twitter/associate/', 302)])
self.assertEqual(response.status_code, 200)
def test_association_user_remove(self):
# User removes association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
self.assertTrue(
self.client.login(username=self.password.username,
password=self.password.username))
response = self.client.post(reverse('twitter_associate'), {
'action': 'remove',
'twitter_id': '1'
})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
def test_association_associated_add(self):
# Associated adds association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key})
self.assertEqual(
response['Location'], 'http://testserver/twitter/associate/'
'?user=twitter&error=user_already_linked')
def test_association_associated_remove(self):
Api = self.mocker.replace(TwitterApi)
userinfo = self.mocker.mock()
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# Associated removes association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertTrue(TwitterUser.objects.get(user=self.twitter))
response = self.client.post(reverse('twitter_associate'), {
'action': 'remove',
'twitter_id': '1'
})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.twitter)
def test_association_user_revoked(self):
# User visits associate after revoking their Twitter credentials.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api(ANY).GetUserInfo()
self.mocker.throw(HTTPError('url', 401, '', {}, None))
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
def test_callback(self):
# User goes directly to the callback page.
response = self.client.get(reverse(oauthtwitter.callback))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User goes directly to the callback page. but tampers with oauth_token
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': 'bad'})
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User comes in through Twitter OAuth, but tampers with oauth_token
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
request.GET
self.mocker.result({'oauth_token': 'bad'})
request.session
self.mocker.result({})
self.mocker.count(1, None)
request.twitter_request_token
self.mocker.result(TOKEN)
# New user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api = self.mocker.replace(TwitterApi)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(AnonymousUser())
userinfo = self.mocker.mock()
cui = self.mocker.replace(cached_user_info)
cui(request, TOKEN)
self.mocker.result(userinfo)
o._authenticate(userinfo=userinfo)
self.mocker.result(None)
# Existing user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(User.objects.get(username='******'))
self.mocker.count(1, 2)
cui(request, TOKEN)
self.mocker.result(userinfo)
self.mocker.count(1, 2)
userinfo.id
self.mocker.result(3)
userinfo.AsJsonString()
self.mocker.result('{}')
with self.mocker:
response = o.callback(request)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o.callback(request)
self.assertEqual(response['Location'],
reverse(oauthtwitter.register))
response = o.callback(request)
self.assertEqual(response['Location'], '/home/')
def test_signin(self):
response = self.client.get(reverse('twitter_signin'))
prefix = 'http://twitter.com/oauth/authenticate?'
self.assertTrue(response['Location'].startswith(prefix),
response['Location'])
def test_register(self):
# User goes directly to the register page.
response = self.client.get(reverse(oauthtwitter.register))
self.assertTrue(response['Location'], settings.LOGIN_URL)
# User is logged in
self.assertTrue(
self.client.login(username='******', password='******'))
response = self.client.get(reverse(oauthtwitter.register))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_REDIRECT_URL)
# New user comes in through Twitter
request = self.mocker.mock()
request.user
self.mocker.result(AnonymousUser())
self.mocker.count(1, None)
RC = self.mocker.replace('django.template.RequestContext')
RC(ANY)
self.mocker.result({})
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.screen_name
self.mocker.result('unknown')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('GET')
# New user posts form through Twitter
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo.id
self.mocker.result(2)
userinfo.screen_name
self.mocker.result('unknown')
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('POST')
request.POST
self.mocker.result({'username': '******'})
o = self.mocker.patch(oauthtwitter)
o._login_and_redirect(request=request, user=ANY)
self.mocker.result('New user')
with self.mocker:
response = oauthtwitter.register(request)
self.assertEqual(response.status_code, 200)
response = o.register(request)
self.assertEqual(response, 'New user')
self.assertTrue(User.objects.get(username='******'))
def test_authenticate(self):
# Associated Twitter user
twitter = self.mocker.mock()
twitter.id
self.mocker.result(1)
# Unknown Twitter uesr
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
with self.mocker:
self.assertEqual(oauthtwitter._authenticate(twitter),
User.objects.get(username="******"))
self.assertEqual(oauthtwitter._authenticate(unknown), None)
def test_create_user(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
request.user.is_anonymous()
self.mocker.result(False)
o._login_and_redirect(request=request, user=None)
self.mocker.result('Logged in')
# Anonymous user with new User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
unknown.screen_name
self.mocker.result("unknown")
unknown.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(unknown)
o._login_and_redirect(request=request,
user=MATCH(lambda x: isinstance(x, User)))
self.mocker.result('New user')
# Anonymous user with existing User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
twitter = self.mocker.mock()
twitter.screen_name
self.mocker.result("twitter")
request.twitter_userinfo
self.mocker.result(twitter)
with self.mocker:
response = o._create_user(request)
self.assertEqual(response, 'Logged in')
response = o._create_user(request)
self.assertEqual(response, 'New user')
response = o._create_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_login_and_redirect(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
twitter = User.objects.get(username='******')
request.user
self.mocker.result(twitter)
# No User to log in
True
# Login a Twitter user
o._login(request, twitter)
request.user
self.mocker.result(AnonymousUser())
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.session
self.mocker.result({SUCCESS_URL_KEY: (TOKEN, '/home/')})
request.twitter_request_token
self.mocker.result(TOKEN)
with self.mocker:
response = o._login_and_redirect(request, user=True)
self.assertEqual(response['Location'], settings.LOGIN_REDIRECT_URL)
response = o._login_and_redirect(request, user=None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o._login_and_redirect(request, user=twitter)
self.assertEqual(response['Location'], '/home/')
self.assertEqual(str(twitter.twitter.access_token), str(TOKEN))
self.assertEqual(twitter.twitter.userinfo_json, '{}')
def test_on_new_user(self):
# With auto_create_user
request = self.mocker.mock()
a = self.mocker.patch(OAuthTwitter(auto_create_user=True))
a._create_user(request)
self.mocker.result('auto_create')
# Without
b = self.mocker.patch(oauthtwitter)
with self.mocker:
response = a._on_new_user(request)
self.assertEqual(response, 'auto_create')
response = b._on_new_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_redirect_to_login(self):
response = oauthtwitter._redirect_to_login(None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
