def post(self, *args, **kwargs):
super(AjaxTags, self).post()
new_tag_name = self.request.POST.get('name')
new_tag = None
if Tag.get_by_key(new_tag_name) is None:
new_tag = Tag(name=new_tag_name).put()
response = json.dumps(
None if new_tag is None
else {'key': new_tag.urlsafe(), 'name': new_tag_name})
self.response.out.write(response)
class EditPostTests(BaseTest):
def setUp(self):
super(EditPostTests, self).setUp()
self.test_tag_1 = Tag(name="test tag 1").put()
self.test_tag_2 = Tag(name="test tag 2").put()
self.test_tag_3 = Tag(name="test tag 3").put()
self.test_author = Author(nickname="test", email="*****@*****.**").put()
self.test_post = (
Post(
subject="test post",
mark_down="test mark down",
html="test html",
is_published=True,
author=self.test_author,
tags=[self.test_tag_1],
)
.put()
.get()
)
def test_must_be_admin_to_view_page(self):
self.app.get(get_route("edit_post", key=self.test_post.key.urlsafe()), status=403)
def test_existing_tags_available_on_page_load(self):
self.login("*****@*****.**", admin=True)
response = self.app.get(get_route("edit_post", key=self.test_post.key.urlsafe()))
soup = BeautifulSoup(response.body)
multiselect_box = soup.find("select", {"name": "tags"})
options = multiselect_box.findAll("option")
self.assertEqual(len(options), 3)
def test_existing_post_content_loads_on_edit(self):
self.login("*****@*****.**", admin=True)
response = self.app.get(get_route("edit_post", key=self.test_post.key.urlsafe()), status=200)
edit_form = response.form
self.assertEqual(edit_form["subject"].value, "test post")
self.assertEqual(edit_form["mark_down"].value, "test mark down")
self.assertEqual(edit_form["is_published"].value, "on")
self.assertEqual(edit_form["tags"].value, [self.test_tag_1.urlsafe()])
self.assertEqual(edit_form["key"].value, self.test_post.key.urlsafe())
class ModelDeserializationTests(BaseTest):
def setUp(self):
super(ModelDeserializationTests, self).setUp()
self.login("*****@*****.**")
self.test_key = Tag(name="Test Tag for Key").put()
self.testing_model = (
TestModel(
bool_prop=True,
string_prop="unmodified",
text_prop="unmodified",
datetime_prop=datetime(1982, 5, 21, 16, 0, 0, 0),
)
.put()
.get()
)
def test_can_deserialize_a_dict_to_model(self):
test_dict = {
"bool_prop": True,
"string_prop": "string value",
"text_prop": "text value",
"datetime_prop": "1982-05-21 16:00",
"key_prop": self.test_key.urlsafe(),
}
deser_model = TestModel.deserialize(test_dict)
self.assertTrue(deser_model.bool_prop)
self.assertEqual(deser_model.string_prop, test_dict["string_prop"])
self.assertEqual(deser_model.text_prop, test_dict["text_prop"])
self.assertEqual(deser_model.datetime_prop, datetime(1982, 5, 21, 16, 0, 0, 0))
self.assertEqual(deser_model.key_prop, self.test_key)
def test_can_deserialize_a_serialized_array_with_repeated_keys(self):
post_serialized_array = [
{"name": "repeated_key_prop", "value": self.test_key.urlsafe()},
{"name": "repeated_key_prop", "value": self.test_key.urlsafe()},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_key_prop)
self.assertEqual(len(deser_model.repeated_key_prop), 2)
def test_can_deserialize_a_serialized_array_with_regular_key_prop(self):
post_serialized_array = [{"name": "regular_key_prop", "value": self.test_key.urlsafe()}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.regular_key_prop)
self.assertEqual(deser_model.regular_key_prop, self.test_key)
def test_can_deserialize_serialized_array_with_datetime_props(self):
post_serialized_array = [
{"name": "repeated_datetime_prop", "value": "1982-05-21 16:00"},
{"name": "repeated_datetime_prop", "value": "1982-05-21 17:00"},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_datetime_prop)
self.assertEqual(len(deser_model.repeated_datetime_prop), 2)
self.assertIn(datetime(1982, 5, 21, 16, 0, 0, 0), deser_model.repeated_datetime_prop)
self.assertIn(datetime(1982, 5, 21, 17, 0, 0, 0), deser_model.repeated_datetime_prop)
def test_can_deserialize_serialized_array_with_regular_datetime_prop(self):
post_serialized_array = [{"name": "regular_datetime_prop", "value": "1982-05-21 16:00"}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.regular_datetime_prop)
self.assertEqual(deser_model.regular_datetime_prop, datetime(1982, 5, 21, 16, 0, 0, 0))
def test_can_deserialize_serialized_array_with_date_props(self):
post_serialized_array = [
{"name": "repeated_date_prop", "value": "1982-05-21"},
{"name": "repeated_date_prop", "value": "1982-05-21"},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_date_prop)
self.assertEqual(len(deser_model.repeated_date_prop), 2)
self.assertIn(datetime(1982, 5, 21), deser_model.repeated_date_prop)
self.assertIn(datetime(1982, 5, 21), deser_model.repeated_date_prop)
def test_can_deserialize_serialized_array_with_regular_date_prop(self):
post_serialized_array = [{"name": "regular_date_prop", "value": "1982-05-21"}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.regular_date_prop)
self.assertEqual(deser_model.regular_date_prop, datetime(1982, 5, 21))
def test_can_deserialize_a_serialized_array_with_repeated_bool_props(self):
post_serialized_array = [
{"name": "repeated_bool_prop", "value": "on"},
{"name": "repeated_bool_prop", "value": ""},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_bool_prop)
self.assertEqual(len(deser_model.repeated_bool_prop), 2)
self.assertIn(True, deser_model.repeated_bool_prop)
self.assertIn(False, deser_model.repeated_bool_prop)
def test_can_deserialize_a_serialized_array_with_regular_bool_prop(self):
post_serialized_array = [{"name": "regular_bool_prop", "value": "on"}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertTrue(deser_model.regular_bool_prop)
def test_can_deserialize_serialized_array_with_repeated_string_prop(self):
post_serialized_array = [
{"name": "repeated_string_prop", "value": "first string"},
{"name": "repeated_string_prop", "value": "second string"},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_string_prop)
self.assertEqual(len(deser_model.repeated_string_prop), 2)
self.assertIn("first string", deser_model.repeated_string_prop)
self.assertIn("second string", deser_model.repeated_string_prop)
def test_can_deserialize_a_serialized_array_with_regular_string_prop(self):
post_serialized_array = [{"name": "regular_string_prop", "value": "just a test string"}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertEqual(deser_model.regular_string_prop, "just a test string")
def test_can_deserialize_a_serialized_array_with_repeated_text_prop(self):
post_serialized_array = [
{"name": "repeated_text_prop", "value": "this is some sample text."},
{"name": "repeated_text_prop", "value": "this is some more sample text."},
]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertIsNotNone(deser_model.repeated_text_prop)
self.assertEqual(len(deser_model.repeated_text_prop), 2)
self.assertIn("this is some sample text.", deser_model.repeated_text_prop)
self.assertIn("this is some more sample text.", deser_model.repeated_text_prop)
def test_can_deserialize_a_serialized_array_with_regular_text_prop(self):
post_serialized_array = [{"name": "regular_text_prop", "value": "just a regular text prop"}]
deser_model = TestModel2.deserialize(post_serialized_array)
self.assertIsNotNone(deser_model)
self.assertEqual(deser_model.regular_text_prop, "just a regular text prop")
def test_can_update_existing_model_using_a_dict(self):
update_dict = {
"key": self.testing_model.key.urlsafe(),
"bool_prop": True,
"string_prop": "modified",
"text_prop": "modified",
"datetime_prop": "2012-07-04 12:00",
"key_prop": self.test_key.urlsafe(),
}
updated_model = TestModel.deserialize(update_dict)
self.assertEqual(updated_model.key, self.testing_model.key)
self.assertTrue(updated_model.bool_prop)
self.assertEqual(updated_model.string_prop, "modified")
self.assertEqual(updated_model.text_prop, "modified")
self.assertEqual(updated_model.datetime_prop, datetime(2012, 7, 4, 12))
def test_can_update_existing_model_using_a_serialized_array(self):
update_serialize_array = [
{"name": "key", "value": self.testing_model.key.urlsafe()},
{"name": "bool_prop", "value": ""},
{"name": "string_prop", "value": "modified"},
{"name": "text_prop", "value": "modified"},
{"name": "datetime_prop", "value": "2012-07-04 12:00"},
]
updated_model = TestModel.deserialize(update_serialize_array)
self.assertEqual(updated_model.key, self.testing_model.key)
self.assertFalse(updated_model.bool_prop)
self.assertEqual(updated_model.string_prop, "modified")
self.assertEqual(updated_model.text_prop, "modified")
self.assertEqual(updated_model.datetime_prop, datetime(2012, 7, 4, 12))
def test_missing_bool_prop_assumed_to_be_false(self):
test_dict = {
"key": self.testing_model.key.urlsafe(),
"string_prop": "string value",
"text_prop": "text value",
"datetime_prop": "1982-05-21 16:00",
"key_prop": self.test_key.urlsafe(),
}
updated_model = TestModel.deserialize(test_dict)
self.assertFalse(updated_model.bool_prop)
