def test_day_after_last_day_of_classes(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
# spring
now_request.session["myuw_override_date"] = "2013-06-08"
values = get_card_visibilty_date_values(now_request)
self.assertFalse(values["is_after_grade_submission_deadline"])
self.assertTrue(values["is_after_last_day_of_classes"])
self.assertTrue(
values["is_after_start_of_registration_display_period"])
self.assertTrue(values["is_before_end_of_finals_week"])
# This is a poorly named value - it's really last day + 1
self.assertFalse(values["is_before_last_day_of_classes"])
self.assertTrue(
values["is_before_end_of_registration_display_period"])
# 2013 winter after
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-16"
now = get_now(now_request)
self.assertTrue(
is_after_last_day_of_classes(now, now_request))
self.assertFalse(
is_before_last_day_of_classes(now, now_request))
def test_get_eod_current_term_last_instruction(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-05-10"
self.assertEqual(
get_eod_current_term_last_instruction(now_request),
datetime(2013, 6, 8, 0, 0, 0))
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertEqual(
get_eod_current_term_last_instruction(now_request, True),
datetime(2013, 7, 25, 0, 0, 0))
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertEqual(
get_eod_current_term_last_instruction(now_request),
datetime(2013, 8, 24, 0, 0, 0))
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertEqual(
get_eod_current_term_last_instruction(now_request, True),
datetime(2013, 8, 24, 0, 0, 0))
def test_day_before_last_day_of_classes(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-06-06"
values = get_card_visibilty_date_values(now_request)
self.assertFalse(values["is_after_grade_submission_deadline"])
self.assertFalse(values["is_after_last_day_of_classes"])
self.assertTrue(
values["is_after_start_of_registration_display_period"])
self.assertTrue(values["is_before_end_of_finals_week"])
self.assertTrue(values["is_before_last_day_of_classes"])
self.assertTrue(
values["is_before_end_of_registration_display_period"])
now = get_now(now_request)
self.assertTrue(is_before_last_day_of_classes(now, now_request))
self.assertTrue(
is_after_bof_and_before_eof_reg_period(now, now_request))
# winter
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-14"
now = get_now(now_request)
self.assertTrue(
is_before_last_day_of_classes(now, now_request))
self.assertFalse(
is_after_last_day_of_classes(now, now_request))
def test_json_for_evaluation(self):
with self.settings(
RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS,
RESTCLIENTS_PWS_DAO_CLASS=FDAO_PWS,
RESTCLIENTS_IASYSTEM_DAO_CLASS=FDAO_IAS,
):
evals = get_evaluation_by_id(132136, "seattle")
self.assertIsNotNone(evals)
now_request = RequestFactory().get("/")
# after show date, before open date
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-11"
json_data = json_for_evaluation(now_request, evals, None)
self.assertIsNone(json_data)
# after open date
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-13"
json_data = json_for_evaluation(now_request, evals, None)
self.assertIsNotNone(json_data)
self.assertEqual(len(json_data["evals"]), 1)
self.assertEqual(json_data["close_date"], "2013-03-23T07:59:59+00:00")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-22"
json_data = json_for_evaluation(now_request, evals, None)
self.assertIsNotNone(json_data)
self.assertEqual(len(json_data["evals"]), 1)
self.assertEqual(json_data["close_date"], "2013-03-23T07:59:59+00:00")
# before hide date but after close date
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-24"
json_data = json_for_evaluation(now_request, evals, None)
self.assertIsNone(json_data)
def test_summer_term_overlaped(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
term = Term()
term.year = 2013
term.quarter = "summer"
section = Section()
section.summer_term = "A-term"
section.term = term
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertTrue(summer_term_overlaped(now_request, section))
section.summer_term = "Full-term"
self.assertFalse(summer_term_overlaped(now_request, section))
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertTrue(summer_term_overlaped(now_request, section))
section.summer_term = "B-term"
self.assertTrue(summer_term_overlaped(now_request, section))
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-10"
self.assertTrue(summer_term_overlaped(now_request, 'None'))
self.assertTrue(summer_term_overlaped(now_request, '-'))
def test_bigger_priority_is_first(self):
"""
Test that records with bigger priority comes first
make two request, modify prior of them,
ensure that request with bigger priority comes first
"""
from django.contrib.auth.models import AnonymousUser
from .middleware import StoreRequestsDB
request = RequestFactory().get('')
request.user = AnonymousUser()
request.session = {}
StoreRequestsDB().process_request(request)
count = HTTPRequest.objects.all().count()
record = HTTPRequest.objects.all()[0]
record.priority = 1
record.save()
pk = record.pk
request = RequestFactory().get('')
request.user = AnonymousUser()
request.session = {}
StoreRequestsDB().process_request(request)
self.assertEqual(HTTPRequest.objects.all().count(), count + 1)
record = HTTPRequest.objects.all()[0]
self.assertEqual(pk, record.pk)
def test_verify_session(self):
lti = LTI('session', 'any')
request = RequestFactory().post('/lti/')
with self.assertRaises(LTINotInSessionException):
request.session = {}
lti.verify(request)
request.session = {LTI_SESSION_KEY: True}
self.assertTrue(lti.verify(request))
def test_in_show_grades_period(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
term = _get_term_by_year_and_quarter(2013, "winter")
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-27"
self.assertTrue(in_show_grades_period(term, now_request))
now_request.session = {}
# spring quarter starts
now_request.session["myuw_override_date"] = "2013-04-01"
self.assertFalse(in_show_grades_period(term, now_request))
def test_eof_last_final_exam(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-10"
self.assertEqual(get_eof_last_final_exam(now_request), datetime(2013, 3, 23, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertEqual(get_eof_last_final_exam(now_request, True), datetime(2013, 7, 25, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertEqual(get_eof_last_final_exam(now_request), datetime(2013, 8, 24, 0, 0, 0))
def test_eof_7d_after_class_start(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-05-10"
self.assertEqual(get_eof_7d_after_class_start(now_request), datetime(2013, 4, 9, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertEqual(get_eof_7d_after_class_start(now_request), datetime(2013, 7, 2, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertEqual(get_eof_7d_after_class_start(now_request), datetime(2013, 7, 2, 0, 0, 0))
def test_bof_1st_instruction(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-05-10"
self.assertEqual(get_bof_1st_instruction(now_request), datetime(2013, 4, 1, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertEqual(get_bof_1st_instruction(now_request), datetime(2013, 6, 24, 0, 0, 0))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertEqual(get_bof_1st_instruction(now_request), datetime(2013, 6, 24, 0, 0, 0))
def test_is_in_summer_a_term(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertTrue(is_in_summer_a_term(now_request))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertFalse(is_in_summer_a_term(now_request))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-10"
self.assertFalse(is_in_summer_a_term(now_request))
def test_is_past(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
term = _get_term_by_year_and_quarter(2014, "winter")
self.assertEqual(term.year, 2014)
self.assertEqual(term.quarter, "winter")
now_request = RequestFactory().get("/")
now_request.session = {}
self.assertFalse(is_past(term, now_request))
term = _get_term_by_year_and_quarter(2013, "winter")
self.assertEqual(term.year, 2013)
self.assertEqual(term.quarter, "winter")
now_request = RequestFactory().get("/")
now_request.session = {}
self.assertTrue(is_past(term, now_request))
def test_term_matched(self):
with self.settings(RESTCLIENTS_SWS_DAO_CLASS=FDAO_SWS):
now_request = RequestFactory().get("/")
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-07-10"
self.assertTrue(term_matched(now_request, "A-term"))
self.assertFalse(term_matched(now_request, "Full-term"))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-08-10"
self.assertTrue(term_matched(now_request, "B-term"))
self.assertTrue(term_matched(now_request, "Full-term"))
now_request.session = {}
now_request.session["myuw_override_date"] = "2013-03-10"
self.assertTrue(term_matched(now_request, "None"))
self.assertTrue(term_matched(now_request, "-"))
def test_remove_unit(self, delete, get):
data = {
"name": "app1",
"units": [
{"Ip": "10.10.10.10"},
{"Ip": "9.9.9.9"},
{"Ip": "8.8.8.8"},
{"Ip": "7.7.7.7"}
],
}
response_mock = Mock()
response_mock.json.return_value = data
get.return_value = response_mock
data = {"units": '1'}
request = RequestFactory().post("/", data)
request.session = {"tsuru_token": "admin"}
ChangeUnit.as_view()(request, app_name="app_name")
delete.assert_called_with(
'{}/apps/app_name/units'.format(settings.TSURU_HOST),
data='3',
headers={'authorization': 'admin'}
)
get.assert_called_with(
'{}/apps/app_name'.format(settings.TSURU_HOST),
headers={'authorization': 'admin'}
)
def test_redirect_to_the_app_detail_page(self, get):
data = {
"name": "app1",
"units": [
{"Ip": "10.10.10.10"},
{"Ip": "9.9.9.9"},
],
}
response_mock = Mock(status_code=200)
response_mock.json.return_value = data
get.return_value = response_mock
data = {"units": '2'}
request = RequestFactory().post("/", data)
request.session = {"tsuru_token": "admin"}
response = ChangeUnit.as_view()(request, app_name="app_name")
self.assertEqual(302, response.status_code)
self.assertEqual("/apps/app_name/", response.items()[1][1])
get.assert_called_with(
'{}/apps/app_name'.format(settings.TSURU_HOST),
headers={'authorization': 'admin'}
)
def test_should_use_detail_template(self):
request = RequestFactory().get("/")
request.session = {"tsuru_token":"admin"}
with mock.patch("requests.get") as get:
get.return_value = mock.Mock(status_code=200, json={})
response = AppDetail.as_view()(request, app_name="app1")
self.assertEqual("apps/details.html", response.template_name)
def test_add_unit(self, put, get):
data = {
"name": "app1",
"units": [
{"Ip": "10.10.10.10"},
{"Ip": "9.9.9.9"},
],
}
response_mock = Mock(status_code=200)
response_mock.json.return_value = data
get.return_value = response_mock
data = {"units": '10'}
request = RequestFactory().post("/", data)
request.session = {"tsuru_token": "admin"}
ChangeUnit.as_view()(request, app_name="app_name")
put.assert_called_with(
'{}/apps/app_name/units'.format(settings.TSURU_HOST),
data='8',
headers={'authorization': 'admin'}
)
get.assert_called_with(
'{}/apps/app_name'.format(settings.TSURU_HOST),
headers={'authorization': 'admin'}
)
def test_new_user(self):
"""Tests that new users get redirected to new_user page"""
# Create a user that has no profile--this is the sign that the
# user is new!
new_user = UserFactory(profile=None)
self.client_login_user(new_user)
# Now do some ridiculous setup so we can call login_success()
# on the Verify and see if it did what it should be doing.
# FIXME - this can go away post django-browserid 0.9
new_user.backend = 'django_browserid.auth.BrowserIDBackend'
post_request = RequestFactory().post(reverse('browserid.login'))
post_request.user = new_user
post_request.session = self.client.session
fv = FjordVerify()
fv.user = new_user
fv.request = post_request
resp = fv.login_success()
eq_(200, resp.status_code)
body = json.loads(resp.content)
eq_(body['redirect'], reverse('new-user-view'))
def test_should_redirect_to_login_page_if_user_is_not_authenticated(self):
request = RequestFactory().get('/')
request.session = {}
response = StubView.as_view()(request)
self.assertIsInstance(response, HttpResponseRedirect)
expected_url = "%s?next=%s" % (reverse('login'), request.path)
self.assertEqual(expected_url, response['Location'])
def test_get(self, token_mock, get_backend_mock):
token_mock.return_value = True
backend_mock = Mock()
backend_mock.cpu_max.return_value = {}
get_backend_mock.return_value = backend_mock
v = views.Metric
original_get_app = v.get_app
v.get_app = Mock()
v.get_app.return_value = {}
original_get_envs = v.get_envs
v.get_envs = Mock()
v.get_envs.return_value = {}
view = v.as_view()
def cleanup():
v.get_app = original_get_app
v.get_envs = original_get_envs
self.addCleanup(cleanup)
request = RequestFactory().get("/ble/?metric=cpu_max&date_range=2h/h&interval=30m&process_name=web")
request.session = {"tsuru_token": "token"}
response = view(request, app_name="app_name")
self.assertEqual(response.status_code, 200)
get_backend_mock.assert_called_with({"envs": {}}, "token", date_range=u"2h/h", process_name=u"web")
backend_mock.cpu_max.assert_called_with(interval=u"30m")
def test_callback_with_permissions(self, post_mock):
url = "{}/users/info".format(settings.TSURU_HOST)
httpretty.register_uri(
httpretty.GET, url, status=200,
body='{"Permissions": [{"Name":"healing.read"}, {"Name": "", "ContextType": "global"}]}'
)
response_mock = mock.Mock(status_code=200)
response_mock.json.return_value = {"token": "xpto"}
post_mock.return_value = response_mock
request = RequestFactory().get('/', {"code": "somecode"})
request.META['HTTP_HOST'] = 'localhost:3333'
request.session = {"next_url": "/apps"}
response = Callback.as_view()(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, "/apps")
self.assertEqual(request.session["tsuru_token"], "type xpto")
self.assertDictEqual(request.session["permissions"], {"healing": True, "admin": True})
expected_url = 'http://localhost:8080/auth/login'
expected_data = {
"redirectUrl": "http://localhost:3333/auth/callback/",
"code": "somecode"
}
post_mock.assert_called_with(expected_url, data=expected_data)
def test_targz(self, token_is_valid, post):
response_mock = Mock(status_code=200)
response_mock.iter_lines.return_value = iter(["expected"])
post.return_value = response_mock
token_is_valid.return_value = True
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
zip_file = open(os.path.join(BASE_DIR, "example.zip"))
encoded = encodestring(zip_file.read())
request = RequestFactory().post("/", {"filecontent": encoded})
request.session = {"tsuru_token": "admin"}
tar_path = os.path.join(BASE_DIR, "example.tar.gz")
def deploy(self, request, app_name, content):
tar_file = open(tar_path, "wb")
tar_file.write(content.getvalue())
tar_file.close()
view = ListDeploy
view.deploy = deploy
view.as_view()(request, app_name="appname")
cmd = ["tar", "zxvf", "{}".format(tar_path), "-C", "/tmp"]
pipes = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
_, stderr = pipes.communicate()
self.assertEqual(pipes.returncode, 0)
self.assertNotIn("Damaged", stderr)
def _iter_scorable_xmodules(block_structure):
"""
Loop through all the blocks locators in the block structure, and retrieve
the module (XModule or XBlock) associated with that locator.
For implementation reasons, we need to pull the max_score from the
XModule, even though the data is not user specific. Here we bind the
data to a SystemUser.
"""
request = RequestFactory().get('/dummy-collect-max-grades')
user = SystemUser()
request.user = user
request.session = {}
root_block = block_structure.get_xblock(block_structure.root_block_usage_key)
course_key = block_structure.root_block_usage_key.course_key
cache = FieldDataCache.cache_for_descriptor_descendents(
course_id=course_key,
user=request.user,
descriptor=root_block,
descriptor_filter=lambda descriptor: descriptor.has_score,
)
for block_locator in block_structure.post_order_traversal():
block = block_structure.get_xblock(block_locator)
if getattr(block, 'has_score', False):
module = get_module_for_descriptor(user, request, block, cache, course_key)
yield module
def _create_mocked_tweet_request(self):
request = RequestFactory().post(
reverse('customercare.twitter_post'),
{'reply_to': 1,
'content': '@foobar try Aurora! #fxhelp'})
request.session = {}
request.twitter = Mock()
request.twitter.authed = True
request.twitter.api = Mock()
return_value = {
'id': 123456790,
'text': '@foobar try Aurora! #fxhelp',
'created_at': datetime.strftime(datetime.utcnow(),
'%a %b %d %H:%M:%S +0000 %Y'),
'user': {
'lang': 'en',
'id': 42,
'screen_name': 'r1cky',
'profile_image_url': 'http://example.com/profile.jpg',
'profile_image_url_https': 'https://example.com/profile.jpg',
}
}
request.twitter.api.update_status.return_value = return_value
credentials = {'screen_name': 'r1cky'}
request.twitter.api.verify_credentials.return_value = credentials
request.user = user(save=True)
return request
def test_index_with_token(self):
request = RequestFactory().get("/sleeps/")
request.session = {"token": "TOKEN"}
request.user = mommy.make(User)
resp = index(request)
self.assertEqual(resp.status_code, 200)
def test_login_get(self, get_mock):
request = RequestFactory().get("/")
request.session = {"next_url": "/"}
response = Login.as_view()(request)
self.assertIn("auth/login.html", response.template_name)
form = response.context_data["form"]
self.assertIsInstance(form, LoginForm)
def test_get_context_data(self, get_mock):
request = RequestFactory().get("/")
request.session = {"next_url": "/"}
request.META["HTTP_HOST"] = "localhost:3333"
view = Login()
view.request = request
response_mock = Mock(status_code=200)
response_mock.json.return_value = {
"name": "oauth",
"data": {
"authorizeUrl":
"http://something.com/?redirect=__redirect_url__"
}
}
get_mock.return_value = response_mock
data = view.get_context_data()
self.assertDictEqual(data["scheme_info"], {
"name": "oauth",
"data": {
"authorizeUrl":
"http://something.com/?redirect=__redirect_url__"
},
})
self.assertEqual(
data["authorize_url"],
"http://something.com/?redirect=http://localhost:3333/auth/callback/"
)
def test_callback(self, post_mock):
url = "{}/docker/healing".format(settings.TSURU_HOST)
httpretty.register_uri(httpretty.GET, url, status=403)
response_mock = mock.Mock(status_code=200)
response_mock.json.return_value = {"token": "xpto"}
post_mock.return_value = response_mock
request = RequestFactory().get('/', {"code": "somecode"})
request.META['HTTP_HOST'] = 'localhost:3333'
request.session = {"next_url": "/apps"}
response = Callback.as_view()(request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, "/apps")
self.assertEqual(request.session["tsuru_token"], "type xpto")
self.assertDictEqual(request.session["permissions"], {"healing": False})
expected_url = 'http://localhost:8080/auth/login'
expected_data = json.dumps({
"redirectUrl": "http://localhost:3333/auth/callback/",
"code": "somecode"
})
post_mock.assert_called_with(expected_url, data=expected_data)
def login(self):
SessionStore = import_module(settings.SESSION_ENGINE).SessionStore
sesh = SessionStore()
sesh.save() # To generate session_id
# We'll need a request to call the login() function
request = RequestFactory()
request.session = sesh
request.META = {}
self.user_to_login.backend = 'django.contrib.auth.backends.ModelBackend' # Cheat and make them appear authenticated.
try:
login(request, self.user_to_login)
except AttributeError:
raise TypeError("Need a User to login. This can be specified in three ways: 1) set request.user 2) set the user_to_login attribute of your LoginClump 3) pass a User object to the with_canopy decorator")
try:
target = "%s:%s/" % (self.obj.server_thread.host, self.obj.server_thread.port)
print "Target: %s" % target
self.obj.wd.get(target)
except AttributeError:
raise TypeError("In order to build this canopy, the decorated class must have an attribute 'wd' (a WebDriver instance). Please modify %s to include this." % self.obj)
request.session.save()
self.obj.wd.add_cookie({'name': settings.SESSION_COOKIE_NAME, 'value': sesh.session_key})
self.logged_in = True
def test_should_invoke_view_dispatch_when_user_has_permission(self, get):
get.return_value = Mock(status_code=200)
request = RequestFactory().get('/')
request.session = {'permissions': {"super": True}}
response = StubView.as_view()(request)
self.assertEqual('ok', response.content)
def test_history_form_view_getting_history_abstract_external(self):
request = RequestFactory().post('/')
request.session = 'session'
request._messages = FallbackStorage(request)
request.user = self.user
request.POST = {'_change_history': True}
obj = ConcreteExternal.objects.create(name='test')
obj.name = "new_test"
obj.save()
history = obj.history.all()[0]
admin_site = AdminSite()
admin = SimpleHistoryAdmin(ConcreteExternal, admin_site)
with patch('simple_history.admin.render') as mock_render:
with patch('simple_history.admin.SIMPLE_HISTORY_EDIT', True):
admin.history_form_view(request, obj.id, history.pk)
context = {
# Verify this is set for history object
'original':
history.instance,
'change_history':
True,
'title':
'Revert %s' % force_text(history.instance),
'adminform':
ANY,
'object_id':
obj.id,
'is_popup':
False,
'media':
ANY,
'errors':
ANY,
'app_label':
'tests',
'original_opts':
ANY,
'changelist_url':
'/admin/tests/concreteexternal/',
'change_url':
ANY,
'history_url':
'/admin/tests/concreteexternal/{pk}/history/'.format(pk=obj.pk),
'add':
False,
'change':
True,
'has_add_permission':
admin.has_add_permission(request),
'has_change_permission':
admin.has_change_permission(request, obj),
'has_delete_permission':
admin.has_delete_permission(request, obj),
'has_file_field':
True,
'has_absolute_url':
False,
'form_url':
'',
'opts':
ANY,
'content_type_id':
ANY,
'save_as':
admin.save_as,
'save_on_top':
admin.save_on_top,
'root_path':
getattr(admin_site, 'root_path', None),
}
mock_render.assert_called_once_with(request,
admin.object_history_form_template,
context, **extra_kwargs)
