def test_profile_access_is_authorized(self):
request = MagicMock()
self.assertTrue(self.presta.profile_access_is_authorized(request))
# no global
self.famille.visibility_global = False
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_global = True
request.user = AnonymousUser()
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_prestataire = False
request.user = self.user2
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_prestataire = True
self.assertTrue(self.famille.profile_access_is_authorized(request))
self.famille.visibility_family = False
request.user = self.famille.user
self.assertTrue(self.famille.profile_access_is_authorized(request))
request.user = User.objects.create_user("d", "*****@*****.**", "d")
models.Famille(user=request.user, email="*****@*****.**").save()
self.assertFalse(self.famille.profile_access_is_authorized(request))
self.famille.visibility_family = True
self.assertTrue(self.famille.profile_access_is_authorized(request))
def test_get_cid():
request = MagicMock()
request.user = get_user()
request.context = get_context()
assert get_cid(request) == 1
request.user.active_companies.append(get_company(2))
assert get_cid(request) == 200
# ref bug :#522
request.user = get_manager()
assert get_cid(request, submenu=True) == 200
request.user = get_admin()
assert get_cid(request, submenu=True) == 200
def test_get_cid(self):
request = MagicMock()
request.user = get_user()
request.context = get_context()
self.assertEqual(get_cid(request), 1)
request.user.companies.append(get_company(2))
self.assertEqual(get_cid(request), 200)
# ref bug :#522
request.user = get_manager()
self.assertEqual(get_cid(request), 200)
request.user = get_admin()
self.assertEqual(get_cid(request), 200)
def test_get_cid():
request = MagicMock()
request.user = get_user()
request.context = get_context()
assert get_cid(request) == 1
request.user.companies.append(get_company(2))
assert get_cid(request) == 200
# ref bug :#522
request.user = get_manager()
assert get_cid(request, submenu=True) == 200
request.user = get_admin()
assert get_cid(request, submenu=True) == 200
def _build_mock_request(self, user=None, get=None, post=None):
request = MagicMock()
if user:
request.user = user
request.user.is_authenticated = MagicMock(return_value=True)
else:
request.user = AnonymousUser()
request.GET = {}
request.POST = {}
request.resolver_match.kwargs = {}
if get is not None:
request.GET.update(get)
if post is not None:
request.POST.update(post)
return request
def test_copy_to_category(self):
""" copy all subrecords that don't have _clonable=True and
are not singletons
"""
request = MagicMock()
request.user = self.user;
view = self.setup_view(views.EpisodeCopyToCategoryView, request)
testmodels.Colour.objects.create(
episode=self.episode, name="purple"
)
testmodels.HatWearer.objects.create(
episode=self.episode, name="hat wearer"
)
testmodels.EpisodeName.objects.create(
episode=self.episode, name="episode name"
)
view.post(request, pk=self.episode.pk, category="Outpatient")
new_episode = models.Episode.objects.exclude(id=self.episode.id).get()
self.assertEqual(new_episode.hatwearer_set.get().name, "hat wearer")
self.assertEqual(new_episode.colour_set.count(), 0)
self.assertEqual(new_episode.category_name, "Outpatient")
# a singleton will be created but not populate it
self.assertEqual(
new_episode.episodename_set.filter(name="episode name").count(), 0
)
def test_get_station(self, ChuteStorage, Popen):
ChuteStorage.chuteList = {
self.chute.name: self.chute
}
proc = MagicMock()
Popen.return_value = proc
proc.stdout = [
"Station 12:34:56:78:9a:bc (on wlan0)",
" inactive time: 304 ms",
" rx bytes: 18816",
" rx packets: 75",
" tx bytes: 5386",
" tx packets: 21",
" signal: -29 dBm",
" tx bitrate: 54.0 MBit/s"
]
request = MagicMock()
request.user = User.get_internal_user()
result = self.api.get_station(request, self.chute.name,
self.interface['name'], '12:34:56:78:9a:bc')
station = json.loads(result)
assert station['mac_addr'] == '12:34:56:78:9a:bc'
assert station['rx_bytes'] == '18816'
assert station['signal'] == '-29 dBm'
assert station['tx_bitrate'] == '54.0 MBit/s'
def test_ChuteApi_get_network(ChuteStorage):
update_manager = MagicMock()
update_manager.assign_change_id.return_value = 1
api = chute_api.ChuteApi(update_manager)
iface = {
'name': 'vwlan0',
'type': 'wifi',
'internalIntf': 'wlan0'
}
chute = Chute(name="test")
chute.setCache("networkInterfaces", [iface])
ChuteStorage.chuteList = {
"test": chute
}
request = MagicMock()
request.user = User.get_internal_user()
result = api.get_network(request, "test", "nomatch")
assert result == "{}"
result = api.get_network(request, "test", "vwlan0")
data = json.loads(result)
assert data['name'] == iface['name']
assert data['type'] == iface['type']
assert data['interface'] == iface['internalIntf']
def test_ChuteApi_operations():
update_manager = MagicMock()
update_manager.assign_change_id.return_value = 1
api = chute_api.ChuteApi(update_manager)
body = {
'config': {}
}
request = MagicMock()
request.content.read.return_value = json.dumps(body)
request.user = User.get_internal_user()
functions = [
api.update_chute,
api.stop_chute,
api.start_chute,
api.restart_chute,
api.delete_chute
]
for func in functions:
print("Calling ChuteApi {}".format(func.__name__))
data = func(request, "test")
assert isinstance(data, basestring)
result = json.loads(data)
assert result['change_id'] == 1
def test_ChuteApi_get_chute(ChuteStorage, ChuteContainer):
update_manager = MagicMock()
api = chute_api.ChuteApi(update_manager)
request = MagicMock()
request.user = User.get_internal_user()
container = MagicMock()
container.getStatus.return_value = "running"
ChuteContainer.return_value = container
chute = MagicMock()
chute.name = "test"
chute.state = "running"
chute.version = 5
chute.environment = {}
chute.resources = {}
ChuteStorage.chuteList = {
"test": chute
}
data = api.get_chute(request, chute.name)
assert isinstance(data, basestring)
result = json.loads(data)
assert result['name'] == chute.name
assert result['version'] == chute.version
def test_args(self):
mocked_os = MagicMock()
mocked_log = MagicMock()
mocked_grp = MagicMock()
mocked_pass = MagicMock()
mocked_file = MagicMock()
mocked_args = MagicMock()
mocked_parser = MagicMock()
mocked_urlparse = MagicMock()
mocked_parse_res1 = MagicMock()
mocked_parse_res2 = MagicMock()
mocked_log_handler = MagicMock()
url = '[email protected]:owner/test.git'
mocked_file.mkdtemp.return_value = "/tmp"
mocked_pass.getuser.return_value = "test_user"
mocked_os.getgid.return_value = 1
mocked_os.environ = {}
mocked_os.path.abspath.return_value = "abs/tmp"
mocked_grp.getgrgid().gr_name = "test_group"
mocked_parser.parse_args.return_value = mocked_args
mocked_args.remote_url = url
mocked_parse_res1.scheme = None
mocked_parse_res2.username = "******"
mocked_urlparse.side_effect = [mocked_parse_res1, mocked_parse_res2]
mocked_args.o = "magic=True,not_magic=False"
mocked_args.group = None
mocked_args.repo_path = None
mocked_args.user = None
mocked_args.branch = None
mocked_args.ssh_user = None
mocked_args.sentry_dsn = ''
with patch.multiple('gitfs.utils.args',
os=mocked_os,
grp=mocked_grp,
getpass=mocked_pass,
tempfile=mocked_file,
TimedRotatingFileHandler=mocked_log_handler,
urlparse=mocked_urlparse,
log=mocked_log):
args = Args(mocked_parser)
asserted_results = {
"repo_path": "abs/tmp",
"user": "******",
"group": "test_group",
"branch": "master",
"not_magic": "False",
"ssh_user": "******",
}
for name, value in iteritems(asserted_results):
assert value == getattr(args, name)
assert args.config == mocked_args
assert mocked_pass.getuser.call_count == 1
assert mocked_file.mkdtemp.call_count == 1
mocked_log.setLevel.assert_called_once_with('DEBUG')
mocked_urlparse.assert_has_calls([call(url), call('ssh://' + url)])
mocked_grp.getgrgid.has_calls([call(1)])
def test_delete_pings_integration(self, change):
colour = Colour.objects.create(episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().destroy(mock_request, pk=colour.pk)
self.assertEqual(202, response.status_code)
self.assertEqual(1, change.call_count)
def test_remove_review(self, name, user_check, side_effect=None):
# Create Mocks
#if name == 'manager':
# import ipdb; ipdb.set_trace()
rev_object = MagicMock()
rev_object.pk = '333333'
rev_object.user = self.user
rev_object.organization = self.org
self.user.userprofile.rated_offerings = [self.offering.pk]
self.offering.rating = 3.75
self.offering.comments = ['333333', '444444', '555555', '666666']
rev_object.offering = self.offering
rev_object.rating = 3
review_manager.Review = MagicMock()
review_manager.Review.objects.get.return_value = rev_object
if side_effect:
side_effect(self, rev_object)
error = False
try:
rm = review_manager.ReviewManager()
rm.remove_review(self.user, '333333')
except:
error = True
# Check result
self.assertFalse(error)
self.assertFalse('333333' in self.offering)
self.offering.save.assert_called_once_with()
rev_object.delete.assert_called_once_with()
# Check user or organization models
user_check(self)
def test_list_with_some_contents(self):
c1 = Colour(name="blue", episode=self.episode).save()
c2 = Colour(name="red", episode=self.episode).save()
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().list(mock_request)
data = [
{
u'consistency_token': u'',
u'created': None,
u'created_by_id': None,
u'episode_id': 1,
u'id': 1,
u'name': u'blue',
u'updated': None,
u'updated_by_id': None
},
{
u'consistency_token': u'',
u'created': None,
u'created_by_id': None,
u'episode_id': 1,
u'id': 2,
u'name': u'red',
u'updated': None,
u'updated_by_id': None
}
]
self.assertEqual(data, json.loads(response.content.decode('UTF-8')))
def test_is_user_info(self):
'Test we get the user-object back from a user-info'
userInfo = MagicMock()
userInfo.user = '******'
r = userInfo_to_user(userInfo)
self.assertEqual(userInfo.user, r)
def test_ChuteApi_get_chute(ChuteStorage, ChuteContainer):
update_manager = MagicMock()
api = chute_api.ChuteApi(update_manager)
request = MagicMock()
request.user = User.get_internal_user()
container = MagicMock()
container.getStatus.return_value = "running"
ChuteContainer.return_value = container
chute = MagicMock()
chute.name = "test"
chute.version = 5
chute.environment = {}
chute.resources = {}
ChuteStorage.chuteList = {"test": chute}
data = api.get_chute(request, chute.name)
assert isinstance(data, basestring)
result = json.loads(data)
assert result['name'] == chute.name
assert result['version'] == chute.version
def test_grpc_init(self):
"""
DOC
"""
mobject = MagicMock(spec=Grpc)
mobject.user = '******'
rhandle = MagicMock()
rhandle.os = 'IOS'
try:
Grpc.__init__(mobject, rhandle=rhandle)
except: # pylint: disable=bare-except
pass
self.assertRaises(Exception, Grpc, mobject, {rhandle: rhandle})
# Grpc with host
self.assertEquals(self.grpc.host, '1.1.1.1')
self.assertEquals(self.grpc.user, 'test')
self.assertEquals(self.grpc.password, 'test123')
self.assertEquals(self.grpc.port, 5555)
self.assertEquals(self.grpc.grpc_lib_path, 'my_path')
# Grpc with rhandle
rhandle = MagicMock()
rhandle.os = 'JUNOS'
rhandle.name = MagicMock(return_value='1.1.1.1')
rhandle.USER = MagicMock(return_value='test')
rhandle.PASSWORD = MagicMock(return_value='test123')
obj = Grpc(rhandle=rhandle, grpc_lib_path="path1")
self.assertEquals(obj.port, 50051)
self.assertIsInstance(obj.host, MagicMock)
def assert_expire_in_extended(self, req_path, should_expire_in, should_extend, headers=None, query_string=None):
request = MagicMock(path=req_path)
request.method = "GET"
request.user = MagicMock()
request.user.is_authenticated.return_value = True
thirty_mins_ago = (datetime.datetime.now() - datetime.timedelta(minutes=30)).strftime("%Y-%m-%dT%H:%M:%S.%f")
request.session = {"_session_security": thirty_mins_ago}
if headers:
request.META = headers
if query_string:
request.REQUEST = query_string
before_response = {}
response = self.middleware.process_response(request, before_response)
self.assertIsNotNone(response.get("Session-Expires-In"))
self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0)
self.middleware.process_request(request)
response2 = self.middleware.process_response(request, before_response)
self.assertIsNotNone(response2.get("Session-Expires-In"))
if should_extend:
self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in, delta=1.0)
else:
self.assertIsAlmostEqualMinutes(response.get("Session-Expires-In"), should_expire_in - 30, delta=1.0)
def test_module_render_with_jump_to_id(self):
"""
This test validates that the /jump_to_id/<id> shorthand for intracourse linking works assertIn
expected. Note there's a HTML element in the 'toy' course with the url_name 'toyjumpto' which
defines this linkage
"""
mock_request = MagicMock()
mock_request.user = self.mock_user
course = get_course_with_access(self.mock_user, 'load',
self.course_key)
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
self.course_key, self.mock_user, course, depth=2)
module = render.get_module(
self.mock_user, mock_request,
self.course_key.make_usage_key('html', 'toyjumpto'),
field_data_cache, self.course_key)
# get the rendered HTML output which should have the rewritten link
html = module.render('student_view').content
# See if the url got rewritten to the target link
# note if the URL mapping changes then this assertion will break
self.assertIn(
'/courses/' + self.course_key.to_deprecated_string() +
'/jump_to_id/vertical_test', html)
def test_copy_to_category(self):
""" copy all subrecords that don't have _clonable=True and
are not singletons
"""
request = MagicMock()
request.user = self.user;
view = self.setup_view(views.EpisodeCopyToCategoryView, request)
testmodels.Colour.objects.create(
episode=self.episode, name="purple"
)
testmodels.HatWearer.objects.create(
episode=self.episode, name="hat wearer"
)
testmodels.EpisodeName.objects.create(
episode=self.episode, name="episode name"
)
view.post(request, pk=self.episode.pk, category="Outpatient")
new_episode = models.Episode.objects.exclude(id=self.episode.id).get()
self.assertEqual(new_episode.hatwearer_set.get().name, "hat wearer")
self.assertEqual(new_episode.colour_set.count(), 0)
self.assertEqual(new_episode.category_name, "Outpatient")
# a singleton will be created but not populate it
self.assertEqual(
new_episode.episodename_set.filter(name="episode name").count(), 0
)
def test_update_item_changed(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
consistency_token='frist',
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': 'wat'
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
colour = Colour.objects.get()
self.assertEqual(created, colour.created)
self.assertEqual(self.user, colour.created_by)
self.assertIsNone(colour.updated)
self.assertIsNone(colour.updated_by)
self.assertEqual(409, response.status_code)
def test_module_render_with_jump_to_id(self):
"""
This test validates that the /jump_to_id/<id> shorthand for intracourse linking works assertIn
expected. Note there's a HTML element in the 'toy' course with the url_name 'toyjumpto' which
defines this linkage
"""
mock_request = MagicMock()
mock_request.user = self.mock_user
course = get_course_with_access(self.mock_user, "load", self.course_key)
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
self.course_key, self.mock_user, course, depth=2
)
module = render.get_module(
self.mock_user, mock_request, self.course_key.make_usage_key("html", "toyjumpto"), field_data_cache
)
# get the rendered HTML output which should have the rewritten link
html = module.render(STUDENT_VIEW).content
# See if the url got rewritten to the target link
# note if the URL mapping changes then this assertion will break
self.assertIn("/courses/" + self.course_key.to_deprecated_string() + "/jump_to_id/vertical_test", html)
def test_update(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': colour.consistency_token,
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
updated_colour = Colour.objects.get()
self.assertEqual(created, updated_colour.created)
self.assertEqual(self.user, updated_colour.created_by)
self.assertEqual(date.today(), updated_colour.updated.date())
self.assertEqual(202, response.status_code)
self.assertEqual('green',
json.loads(response.content.decode('UTF-8'))['name'])
def test_user_logged_in(self, get, now):
# user requests email change
user = Mock()
token_object = Mock()
token_object.token = 'sometokencontent'
token_object.user = user
get.return_value = token_object
# user is logged in
request = MagicMock(HttpRequest)
request._messages = Mock()
request.user = user
# user clicks link in his email
result = change_email(request, token_object.token)
self.assertEquals(result.status_code, 302)
get.assert_called_once_with(
token=token_object.token, valid_until__gte=now())
# user stays logged in
self.assertTrue(request.user.is_authenticated())
# token is deleted
token_object.delete.assert_called_once_with()
user.save.assert_called_once_with()
# user email gets changed
self.assertEqual(user.email, token_object.email)
def test_list_with_some_contents(self):
c1 = Colour(name="blue", episode=self.episode).save()
c2 = Colour(name="red", episode=self.episode).save()
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().list(mock_request)
data = [{
u'consistency_token': u'',
u'created': None,
u'created_by_id': None,
u'episode_id': 1,
u'id': 1,
u'name': u'blue',
u'updated': None,
u'updated_by_id': None
}, {
u'consistency_token': u'',
u'created': None,
u'created_by_id': None,
u'episode_id': 1,
u'id': 2,
u'name': u'red',
u'updated': None,
u'updated_by_id': None
}]
self.assertEqual(data, json.loads(response.content.decode('UTF-8')))
def test_delete_pings_integration(self, change):
colour = Colour.objects.create(episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().destroy(mock_request, pk=colour.pk)
self.assertEqual(202, response.status_code)
self.assertEqual(1, change.call_count)
def test_favorite_post_save(self):
instance = MagicMock()
instance.content_object = MagicMock()
instance.content_object.class_name = MagicMock(return_value = 'A')
instance.content_object.owner = MagicMock(return_value = 'B')
instance.user = MagicMock(return_value = 'A')
favorite_post_save(instance, MagicMock())
def test_should_construct_questionnaire(self):
project_name = 'test_poll'
days_active = 3
question = "What poll questionnaire?"
request = MagicMock()
request.user = MagicMock(spec=User)
request.POST = {
'poll_name': project_name,
'active_days': days_active,
'question': question,
'end_date': "2015-4-28T9:45:31"
}
manager = MagicMock(spec=DatabaseManager)
questionnaire_code = 'poll_'
with patch('datawinners.project.create_poll.get_database_manager') as get_database_manager_mock:
with patch('datawinners.project.create_poll.helper.generate_questionnaire_code') as generate_questionnaire_code_mock:
generate_questionnaire_code_mock.return_value = questionnaire_code
get_database_manager_mock.return_value = manager
manager, questionnaire = _construct_questionnaire(request)
self.assertEquals(questionnaire.name, project_name)
self.assertIn(questionnaire_code, questionnaire.form_code)
def test_render_proc_ts(self):
"""
**test_render_proc_ts** * Test that items are grabbed correctly
"""
with patch('cr_hunt.views.add_hunt_its') as addf:
with patch('cr_hunt.views.redirect') as red:
request = MagicMock()
request.method = "POST"
def side_effect(*args):
def second_call(*args):
return 'test321'
request.POST.get.side_effect = second_call
return 'test123'
request.POST.get = MagicMock(side_effect=side_effect)
#request.POST.get('title', '').return_value = 'test123'
#request.POST.get('start', '').return_value = 'test321'
request.user = MagicMock()
attrs = {'is_authenticated.return_value':True}
request.user.configure_mock(**attrs)
request.user.username = '******'
views.render_proc_ts(request)
assert addf.called
addf.assert_called_with('111222', 'test123', 'test321', 'user1')
assert red.called #test that redirect is called
red.assert_called_with('cr_aitem')
red.reset_mock()
attrs = {'is_authenticated.return_value':False}
request.user.configure_mock(**attrs)
views.render_proc_ts(request)
assert red.called
red.assert_called_with('cr_error')
def test_render_main(self):
"""
**test_render_main** * Will test that correct url is called
"""
with patch('cr_hunt.views.render_to_response') as rend:
with patch('cr_hunt.views.redirect') as red:
with patch('cr_hunt.views.gen_hunt_id') as genhid:
with patch('cr_hunt.views.get_cur_count') as getcount:
request = MagicMock()
request.user = MagicMock()
attrs = {'is_authenticated.return_value':True}
request.user.configure_mock(**attrs)
genhid.return_value = 'test1'
request.user.username = MagicMock()
request.user.username.return_value = 'user1'
getcount.return_value = 1
views.render_main(request)
assert rend.called # Check that rend got called
rend.assert_called_with("cr_hunt/cr_hunt_main.html") # Check that correct url is called
self.assertEqual(views.hunt_id, 'test1') #check that hunt_id got reassigned correctly
self.assertEqual(views.i_counter, 1) #check that i_counter is initialized to 0
attrs = {'is_authenticated.return_value':False}
request.user.configure_mock(**attrs)
views.render_main(request)
assert red.called
red.assert_called_with('cr_error')
def setUp(self):
mock_handler = Mock(**{
'has_perm.return_value': False,
'get_permissions.return_value': 'permission.add_article',
})
mock_request = Mock()
mock_request.META = Mock()
mock_request.user = Mock()
mock_request.user.is_active.return_value = True
mock_request.user.is_authenticated.return_value = True
mock_request.user.has_perm.side_effect = mock_handler.has_perm
self.mock_handler = mock_handler
self.mock_request = mock_request
# store original registry
self._original_registry = registry._registry
# clear registry and register mock handler
registry._registry = {}
registry.register(
Article,
Mock(return_value=self.mock_handler)
)
self.view_func = Mock(return_value=HttpResponse)
view_class = type('MockView', (View,), {})
view_class.dispatch = self.view_func
view_class.dispatch = permission_required('permission.add_article')(view_class.dispatch)
view_class_exc = type('MockView', (View,), {})
view_class_exc.dispatch = self.view_func
view_class_exc.dispatch = permission_required('permission.add_article',
raise_exception=True)(view_class_exc.dispatch)
self.view_class_exc = view_class_exc
def test_module_render_with_jump_to_id(self):
"""
This test validates that the /jump_to_id/<id> shorthand for intracourse linking works assertIn
expected. Note there's a HTML element in the 'toy' course with the url_name 'toyjumpto' which
defines this linkage
"""
mock_request = MagicMock()
mock_request.user = self.mock_user
course = get_course_with_access(self.mock_user, self.course_id, "load")
model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
self.course_id, self.mock_user, course, depth=2
)
module = render.get_module(
self.mock_user, mock_request, ["i4x", "edX", "toy", "html", "toyjumpto"], model_data_cache, self.course_id
)
# get the rendered HTML output which should have the rewritten link
html = module.get_html()
# See if the url got rewritten to the target link
# note if the URL mapping changes then this assertion will break
self.assertIn("/courses/" + self.course_id + "/jump_to_id/vertical_test", html)
def test_update_item_changed(self):
created = timezone.now() - timedelta(1)
colour = Colour.objects.create(
name='blue',
episode=self.episode,
consistency_token='frist',
created_by=self.user,
created=created,
)
mock_request = MagicMock(name='mock request')
mock_request.data = {
'name': 'green',
'episode_id': self.episode.pk,
'id': colour.pk,
'consistency_token': 'wat'
}
mock_request.user = self.user
response = self.viewset().update(mock_request, pk=colour.pk)
colour = Colour.objects.get()
self.assertEqual(created, colour.created)
self.assertEqual(self.user, colour.created_by)
self.assertIsNone(colour.updated)
self.assertIsNone(colour.updated_by)
self.assertEqual(409, response.status_code)
def test_module_render_with_jump_to_id(self):
"""
This test validates that the /jump_to_id/<id> shorthand for intracourse linking works assertIn
expected. Note there's a HTML element in the 'toy' course with the url_name 'toyjumpto' which
defines this linkage
"""
mock_request = MagicMock()
mock_request.user = self.mock_user
course = get_course_with_access(self.mock_user, self.course_id, 'load')
model_data_cache = ModelDataCache.cache_for_descriptor_descendents(
self.course_id, self.mock_user, course, depth=2)
module = render.get_module(
self.mock_user,
mock_request,
['i4x', 'edX', 'toy', 'html', 'toyjumpto'],
model_data_cache,
self.course_id
)
# get the rendered HTML output which should have the rewritten link
html = module.get_html()
# See if the url got rewritten to the target link
# note if the URL mapping changes then this assertion will break
self.assertIn('/courses/'+self.course_id+'/jump_to_id/vertical_test', html)
def test_user_logged_in(self, get, now):
# user requests email change
user = Mock()
token_object = Mock()
token_object.token = 'sometokencontent'
token_object.user = user
get.return_value = token_object
# user is logged in
request = MagicMock(HttpRequest)
request._messages = Mock()
request.user = user
# user clicks link in his email
result = change_email(request, token_object.token)
assert result.status_code == 302
get.assert_called_once_with(
token=token_object.token, valid_until__gte=now())
# user stays logged in
assert request.user.is_authenticated()
# token is deleted
token_object.delete.assert_called_once_with()
user.save.assert_called_once_with()
# user email gets changed
assert user.email == token_object.email
def test_episode_list_view(self):
request = MagicMock(name='mock request')
request.user = self.user
view = api.EpisodeListApi()
view.request = request
resp = view.get(tag="eater", subtag="herbivore")
self.assertEqual(200, resp.status_code)
def test_favorite_post_save(self):
instance = MagicMock()
instance.content_object = MagicMock()
instance.content_object.class_name = MagicMock(return_value='A')
instance.content_object.owner = MagicMock(return_value='B')
instance.user = MagicMock(return_value='A')
favorite_post_save(instance, MagicMock())
def test_create_patient_subrecord(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {'name': 'blue', 'episode_id': self.episode.pk,
'patient_id': self.patient.pk}
response = self.patientviewset().create(mock_request)
self.assertEqual('blue', response.data['name'])
def test_remove_review(self, name, user_check, side_effect=None):
# Create Mocks
#if name == 'manager':
# import ipdb; ipdb.set_trace()
rev_object = MagicMock()
rev_object.pk = '333333'
rev_object.user = self.user
rev_object.organization = self.org
self.user.userprofile.rated_offerings = [self.offering.pk]
self.offering.rating = 3.75
self.offering.comments = ['333333', '444444', '555555', '666666']
rev_object.offering = self.offering
rev_object.rating = 3
review_manager.Review = MagicMock()
review_manager.Review.objects.get.return_value = rev_object
if side_effect:
side_effect(self, rev_object)
error = False
try:
rm = review_manager.ReviewManager()
rm.remove_review(self.user, '333333')
except:
error = True
# Check result
self.assertFalse(error)
self.assertFalse('333333' in self.offering)
self.offering.save.assert_called_once_with()
rev_object.delete.assert_called_once_with()
# Check user or organization models
user_check(self)
def test_host_upload(self, ftp_mock, scp_mock):
hobject = MagicMock(spec=Host)
hobject.proxy = True
hobject.proxy_host = 'host'
hobject.proxy_user = '******'
hobject.proxy_password = '******'
hobject.proxy_ssh_key = 'host'
hobject.proxy_port = 'host'
hobject.connect_mode = 'telnet'
hobject.host = 'device-a'
hobject.user = '******'
hobject.password = '******'
hobject.text_port = None
# telnet as connect mode
hobject.controllers_data = {}
hobject.controllers_data['mgt-ip'] = hobject.host
self.assertTrue(Host.upload(hobject, local_file='', remote_file=''))
# ssh as connect mode
hobject.connect_mode = 'ssh'
self.assertTrue(Host.upload(hobject, local_file='', remote_file=''))
# with only user
self.assertTrue(Host.upload(hobject, local_file='', remote_file='',user='******'))
# with only password
self.assertTrue(Host.upload(hobject, local_file='', remote_file='', password="******"))
# with user and password
self.assertTrue(Host.upload(hobject, local_file='', remote_file='', user="******", password="******"))
def test_module_render_with_jump_to_id(self):
"""
This test validates that the /jump_to_id/<id> shorthand for intracourse linking works assertIn
expected. Note there's a HTML element in the 'toy' course with the url_name 'toyjumpto' which
defines this linkage
"""
mock_request = MagicMock()
mock_request.user = self.mock_user
course = get_course_with_access(self.mock_user, self.course_id, 'load')
field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
self.course_id, self.mock_user, course, depth=2)
module = render.get_module(
self.mock_user,
mock_request,
Location('i4x', 'edX', 'toy', 'html', 'toyjumpto'),
field_data_cache,
self.course_id
)
# get the rendered HTML output which should have the rewritten link
html = module.render('student_view').content
# See if the url got rewritten to the target link
# note if the URL mapping changes then this assertion will break
self.assertIn('/courses/' + self.course_id + '/jump_to_id/vertical_test', html)
def test_create_patient_subrecord(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
mock_request.data = {'name': 'blue', 'episode_id': self.episode.pk,
'patient_id': self.patient.pk}
response = self.patientviewset().create(mock_request)
self.assertEqual('blue', json.loads(response.content)['name'])
def setUp(self):
mock_handler = Mock(**{
'has_perm.return_value': False,
'get_permissions.return_value': 'permission.add_article',
})
mock_request = Mock()
mock_request.META = Mock()
mock_request.user = Mock()
mock_request.user.is_active.return_value = True
mock_request.user.is_authenticated.return_value = True
mock_request.user.has_perm.side_effect = mock_handler.has_perm
self.mock_handler = mock_handler
self.mock_request = mock_request
# store original registry
self._original_registry = registry._registry
# clear registry and register mock handler
registry._registry = {}
registry.register(
Article,
Mock(return_value=self.mock_handler)
)
self.view_func = Mock(return_value=HttpResponse())
self.decorated = permission_required('permission.add_article')(self.view_func)
self.decorated_exc = permission_required('permission.add_article',
raise_exception=True)(self.view_func)
def test_get_pull(self, github, fetch_reviews, logging, mongoClient):
database = MagicMock()
database.repositories.find.return_value = [{
'_id':
'4',
'full_name':
'test',
'github_access_token':
'github_access_token'
}]
mongo = MagicMock()
mongo.get_database.return_value = database
mongoClient.return_value = mongo
user = MagicMock()
user.login = '******'
user.date = 5
pull = MagicMock()
pull.title = 'title'
pull.user = user
pull.commits = 4
pull.created_at = datetime.utcnow() - timedelta(days=2)
commit = MagicMock()
commit.author = user
commit.commit.author.date = datetime.utcnow() - timedelta(days=1)
commits = MagicMock()
commits.reversed = [commit]
pull.get_commits.return_value = commits
contributor = MagicMock()
contributor.total = 10
contributor.author = user
repo = MagicMock()
repo.get_stats_contributors.return_value = [contributor]
github_object = MagicMock()
github.Github.return_value = github_object
pulls = [pull]
github_object.get_repo.return_value = repo
repo.get_pulls.return_value = pulls
def fetch_reviews_mock(token):
print('fetch_reviews')
fetch_reviews = fetch_reviews_mock
PullRequest.check_pull_requests()
self.assertEqual(logging.info.call_args_list[1],
(('Repository: test', ), ))
self.assertEqual(logging.info.call_args_list[2],
(('Pull Request: b\'title\'', ), ))
self.assertEqual(logging.info.call_args_list[3],
(('Would merge now', ), ))
def test_list(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = api.MetadataViewSet().list(mock_request)
self.assertEqual(200, response.status_code)
for s in metadata.Metadata.list():
for key, value in s.to_dict(user=self.user).items():
self.assertEqual(response.data[key], value)
def test_get_user_with_me():
"""Test that get_user uses current_user if pk is me."""
user = MagicMock()
user.is_authenticated = True
kwargs = {'user_pk': 'me'}
request = MagicMock()
request.user = user
assert get_user(request, kwargs) == user
def test_delete(self):
colour = Colour.objects.create(episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().destroy(mock_request, pk=colour.pk)
self.assertEqual(202, response.status_code)
with self.assertRaises(Colour.DoesNotExist):
c2 = Colour.objects.get(pk=colour.pk)
def test_delete(self):
colour = Colour.objects.create(episode=self.episode)
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().destroy(mock_request, pk=colour.pk)
self.assertEqual(202, response.status_code)
with self.assertRaises(Colour.DoesNotExist):
c2 = Colour.objects.get(pk=colour.pk)
def test_options_loader(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().list(mock_request)
result = response.data
self.assertIn("hat", result)
self.assertEqual(set(result["hat"]), {"top", "bowler", "high"})
self.assertEqual(response.status_code, 200)
def test_list(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = api.MetadataViewSet().list(mock_request)
self.assertEqual(200, response.status_code)
for s in metadata.Metadata.list():
for key, value in s.to_dict(user=self.user).items():
self.assertEqual(response.data[key], value)
def test_options_loader(self):
mock_request = MagicMock(name='mock request')
mock_request.user = self.user
response = self.viewset().list(mock_request)
result = response.data
self.assertIn("hat", result)
self.assertEqual(set(result["hat"]), {"top", "bowler", "high"})
self.assertEqual(response.status_code, 200)
def test_send_message_saves_message_when_user_in_database(self):
controller = ChatMessageController()
ws = MagicMock()
ws.user = self.from_user
controller.process_message("@to_user some message", ws)
self.assertEquals(MessageModel.objects.count(), 1)
def test_should_return_DataSubmission_for_reporter(self):
user = self._get_reporter_user()
request = MagicMock()
organization = MagicMock(spec=Organization)
with patch('datawinners.alldata.helper.get_organization') as mock_get_organization:
mock_get_organization.return_value = organization
request.user = user
assert helper.get_page_heading(request) == 'Data Submission'
def test_modx_dispatch(self):
self.assertRaises(Http404, render.modx_dispatch, 'dummy', 'dummy',
'invalid Location', 'dummy')
mock_request = MagicMock()
mock_request.FILES.keys.return_value = ['file_id']
mock_request.FILES.getlist.return_value = [
'file'] * (settings.MAX_FILEUPLOADS_PER_INPUT + 1)
self.assertEquals(
render.modx_dispatch(
mock_request, 'dummy', self.location, 'dummy').content,
json.dumps({'success': 'Submission aborted! Maximum %d files may be submitted at once' %
settings.MAX_FILEUPLOADS_PER_INPUT}))
mock_request_2 = MagicMock()
mock_request_2.FILES.keys.return_value = ['file_id']
inputfile = Stub()
inputfile.size = 1 + settings.STUDENT_FILEUPLOAD_MAX_SIZE
inputfile.name = 'name'
filelist = [inputfile]
mock_request_2.FILES.getlist.return_value = filelist
self.assertEquals(
render.modx_dispatch(mock_request_2, 'dummy', self.location,
'dummy').content,
json.dumps({'success': 'Submission aborted! Your file "%s" is too large (max size: %d MB)' %
(inputfile.name, settings.STUDENT_FILEUPLOAD_MAX_SIZE / (1000 ** 2))}))
mock_request_3 = MagicMock()
mock_request_3.POST.copy.return_value = {'position': 1}
mock_request_3.FILES = False
mock_request_3.user = UserFactory()
inputfile_2 = Stub()
inputfile_2.size = 1
inputfile_2.name = 'name'
self.assertIsInstance(
render.modx_dispatch(mock_request_3, 'goto_position',
self.location, self.course_id), HttpResponse)
self.assertRaises(
Http404,
render.modx_dispatch,
mock_request_3,
'goto_position',
self.location,
'bad_course_id'
)
self.assertRaises(
Http404,
render.modx_dispatch,
mock_request_3,
'goto_position',
['i4x', 'edX', 'toy', 'chapter', 'bad_location'],
self.course_id
)
self.assertRaises(
Http404,
render.modx_dispatch,
mock_request_3,
'bad_dispatch',
self.location,
self.course_id
)
def test_should_return_AllData_for_pro_sms_account(self):
user = self._get_normal_user()
request = MagicMock()
organization = MagicMock(spec=Organization)
organization.is_pro_sms = True
with patch('datawinners.alldata.helper.get_organization') as mock_get_organization:
mock_get_organization.return_value = organization
request.user = user
assert helper.get_page_heading(request) == 'Questionnaires & Polls'
def test_retrieve(self):
patient = models.Patient.objects.create()
mock_request = MagicMock(name='request')
mock_request.user = self.user
models.PatientRecordAccess.objects.create(patient=patient, user=self.user)
response = api.PatientRecordAccessViewSet().retrieve(mock_request, pk=patient.pk).content
loaded = json.loads(response)
self.assertEqual(patient.id, loaded[0]['patient'])
self.assertEqual(self.user.username, loaded[0]['username'])
