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_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_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_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_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_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'])