def test_serialize(self):
model = models.OrmModelStub()
model.name = "foo"
model.age = None
model.password = "******"
model.set_hidden(["password"])
model.set_relation(
"names",
Collection(
[models.OrmModelStub(bar="baz"), models.OrmModelStub(bam="boom")]
),
)
model.set_relation("partner", models.OrmModelStub(name="jane"))
model.set_relation("group", None)
model.set_relation("multi", Collection())
d = model.serialize()
self.assertIsInstance(d, dict)
self.assertEqual("foo", d["name"])
self.assertEqual("baz", d["names"][0]["bar"])
self.assertEqual("boom", d["names"][1]["bam"])
self.assertEqual("jane", d["partner"]["name"])
self.assertIsNone(d["group"])
self.assertEqual([], d["multi"])
self.assertIsNone(d["age"])
self.assertNotIn("password", d)
model.set_appends(["appendable"])
d = model.to_dict()
self.assertEqual("appended", d["appendable"])
def test_to_dict_uses_mutators(self):
model = models.OrmModelStub()
model.list_items = [1, 2, 3]
d = model.to_dict()
self.assertEqual([1, 2, 3], d["list_items"])
model = models.OrmModelStub(list_items=[1, 2, 3])
d = model.to_dict()
self.assertEqual([1, 2, 3], d["list_items"])
def test_update_process_uses_old_primary_key(self):
query = flexmock(Builder)
query.should_receive("where").once().with_args("id", 1)
query.should_receive("update").once().with_args({"id": 2, "name": "john"})
model = models.OrmModelStub()
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None))
)
model._update_timestamps = mock.MagicMock()
events = flexmock(Event())
model.__dispatcher__ = events
events.should_receive("fire").once().with_args(
"saving: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"updating: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"updated: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"saved: %s" % model.__class__.__name__, model
).and_return(True)
model.id = 1
model.sync_original()
model.id = 2
model.name = "john"
model.set_exists(True)
self.assertTrue(model.save())
model.new_query.assert_called_once_with()
self.assertTrue(model._update_timestamps.called)
def test_guarded(self):
model = models.OrmModelStub()
model.guard(["name", "age"])
model.fill(name="foo", age="bar", foo="bar")
self.assertFalse(hasattr(model, "name"))
self.assertFalse(hasattr(model, "age"))
self.assertEqual("bar", model.foo)
def test_hidden_can_also_exclude_relationships(self):
model = models.OrmModelStub()
model.name = "John"
model.set_relation("foo", ["bar"])
model.set_hidden(["foo", "list_items", "password"])
d = model.to_dict()
self.assertEqual({"name": "John"}, d)
def test_visible_creates_dict_whitelist(self):
model = models.OrmModelStub()
model.set_visible(["name"])
model.name = "John"
model.age = 28
d = model.to_dict()
self.assertEqual({"name": "John"}, d)
def test_unguard_allows_anything(self):
model = models.OrmModelStub()
model.unguard()
model.guard(["*"])
model.fill(name="foo", age=28)
self.assertEqual("foo", model.name)
self.assertEqual(28, model.age)
model.reguard()
def test_mutator_cache_is_populated(self):
model = models.OrmModelStub()
expected_attributes = sorted(["list_items", "password", "appendable"])
self.assertEqual(
expected_attributes, sorted(list(model._get_mutated_attributes().keys()))
)
def test_get_attribute_raise_attribute_error(self):
model = models.OrmModelStub()
try:
relation = model.incorrect_relation
self.fail("AttributeError not raised")
except AttributeError:
pass
def test_hidden_are_ignored_when_visible(self):
model = models.OrmModelStub(name="john", age=28, id="foo")
model.set_visible(["name", "id"])
model.set_hidden(["name", "age"])
d = model.to_dict()
self.assertIn("name", d)
self.assertIn("id", d)
self.assertNotIn("age", d)
def test_connection_management(self):
resolver = flexmock(DatabaseManager)
resolver.should_receive("connection").once().with_args("foo").and_return("bar")
models.OrmModelStub.set_connection_resolver(DatabaseManager({}))
model = models.OrmModelStub()
model.set_connection("foo")
self.assertEqual("bar", model.get_connection())
def test_attributes_manipulation(self):
model = models.OrmModelStub()
model.name = "foo"
self.assertEqual("foo", model.name)
del model.name
self.assertFalse(hasattr(model, "name"))
model.list_items = {"name": "john"}
self.assertEqual({"name": "john"}, model.list_items)
attributes = model.get_attributes()
self.assertEqual(json.dumps({"name": "john"}), attributes["list_items"])
def test_dirty_attributes(self):
model = models.OrmModelStub(foo="1", bar=2, baz=3)
model.foo = 1
model.bar = 20
model.baz = 30
self.assertTrue(model.is_dirty())
self.assertTrue(model.is_dirty("foo"))
self.assertTrue(model.is_dirty("bar"))
self.assertTrue(model.is_dirty("baz"))
self.assertTrue(model.is_dirty("foo", "bar", "baz"))
def test_calculated_attributes(self):
model = models.OrmModelStub()
model.password = "******"
attributes = model.get_attributes()
self.assertFalse("password" in attributes)
self.assertEqual("******", model.password)
self.assertEqual(
"5ebe2294ecd0e0f08eab7690d2a6ee69", attributes["password_hash"]
)
self.assertEqual("5ebe2294ecd0e0f08eab7690d2a6ee69", model.password_hash)
def test_new_query_returns_orator_query_builder(self):
conn = flexmock(Connection)
grammar = flexmock(QueryGrammar)
processor = flexmock(QueryProcessor)
conn.should_receive("get_query_grammar").and_return(grammar)
conn.should_receive("get_post_processor").and_return(processor)
resolver = flexmock(DatabaseManager)
resolver.should_receive("connection").and_return(Connection(None))
models.OrmModelStub.set_connection_resolver(DatabaseManager({}))
model = models.OrmModelStub()
builder = model.new_query()
self.assertIsInstance(builder, Builder)
def test_delete_properly_deletes_model(self):
model = models.OrmModelStub()
builder = flexmock(Builder(QueryBuilder(None, None, None)))
builder.should_receive("where").once().with_args("id", 1).and_return(builder)
builder.should_receive("delete").once()
model.new_query = mock.MagicMock(return_value=builder)
model.touch_owners = mock.MagicMock()
model.set_exists(True)
model.id = 1
model.delete()
self.assertTrue(model.touch_owners.called)
def test_insert_is_cancelled_if_creating_event_returns_false(self):
model = flexmock(models.OrmModelStub())
query = flexmock(Builder(flexmock(QueryBuilder(None, None, None))))
model.should_receive("new_query_without_scopes").once().and_return(query)
events = flexmock(Event())
model.__dispatcher__ = events
events.should_receive("fire").once().with_args(
"saving: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"creating: %s" % model.__class__.__name__, model
).and_return(False)
self.assertFalse(model.save())
self.assertFalse(model.exists)
def test_increment(self):
query = flexmock()
model_mock = flexmock(models.OrmModelStub, new_query=lambda: query)
model = models.OrmModelStub()
model.set_exists(True)
model.id = 1
model.sync_original_attribute("id")
model.foo = 2
model_mock.should_receive("new_query").and_return(query)
query.should_receive("where").and_return(query)
query.should_receive("increment")
model.public_increment("foo")
self.assertEqual(3, model.foo)
self.assertFalse(model.is_dirty())
def test_fresh_method(self):
model = flexmock(models.OrmModelStub())
model.id = 1
model.set_exists(True)
flexmock(Builder)
q = flexmock(QueryBuilder(None, None, None))
query = flexmock(Builder(q))
query.should_receive("where").and_return(query)
query.get_query().should_receive("take").and_return(query)
query.should_receive("get").and_return(Collection([]))
model.should_receive("with_").once().with_args("foo", "bar").and_return(query)
model.fresh(["foo", "bar"])
model.should_receive("with_").once().with_args().and_return(query)
model.fresh()
def test_timestamps_are_not_update_with_timestamps_false_save_option(self):
query = flexmock(Builder)
query.should_receive("where").once().with_args("id", 1)
query.should_receive("update").once().with_args({"name": "john"})
model = models.OrmModelStub()
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None))
)
model.id = 1
model.sync_original()
model.name = "john"
model.set_exists(True)
self.assertTrue(model.save({"timestamps": False}))
self.assertFalse(hasattr(model, "updated_at"))
model.new_query.assert_called_once_with()
def test_update_process_does_not_override_timestamps(self):
query = flexmock(Builder)
query.should_receive("where").once().with_args("id", 1)
query.should_receive("update").once().with_args(
{"created_at": "foo", "updated_at": "bar"}
)
model = models.OrmModelStub()
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None))
)
model._update_timestamps = mock.MagicMock()
events = flexmock(Event())
model.__dispatcher__ = events
events.should_receive("fire").once().with_args(
"saving: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"updating: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"updated: %s" % model.__class__.__name__, model
).and_return(True)
events.should_receive("fire").once().with_args(
"saved: %s" % model.__class__.__name__, model
).and_return(True)
model.id = 1
model.sync_original()
model.created_at = "foo"
model.updated_at = "bar"
model.set_exists(True)
self.assertTrue(model.save())
model.new_query.assert_called_once_with()
self.assertTrue(model._update_timestamps.called)
def test_clone_model_makes_a_fresh_copy(self):
model = models.OrmModelStub()
model.id = 1
model.set_exists(True)
model.first = "john"
model.last = "doe"
model.created_at = model.fresh_timestamp()
model.updated_at = model.fresh_timestamp()
# TODO: relation
clone = model.replicate()
self.assertFalse(hasattr(clone, "id"))
self.assertFalse(clone.exists)
self.assertEqual("john", clone.first)
self.assertEqual("doe", clone.last)
self.assertFalse(hasattr(clone, "created_at"))
self.assertFalse(hasattr(clone, "updated_at"))
# TODO: relation
clone.first = "jane"
self.assertEqual("john", model.first)
self.assertEqual("jane", clone.first)
def test_update_process_without_timestamps(self):
query = flexmock(Builder)
query.should_receive("where").once().with_args("id", 1)
query.should_receive("update").once().with_args({"name": "john"})
model = flexmock(models.OrmModelStub())
model.__timestamps__ = False
model.new_query = mock.MagicMock(
return_value=Builder(QueryBuilder(None, None, None))
)
model._update_timestamps = mock.MagicMock()
events = flexmock(Event())
model.__dispatcher__ = events
model.should_receive("_fire_model_event").and_return(True)
model.id = 1
model.sync_original()
model.name = "john"
model.set_exists(True)
self.assertTrue(model.save())
model.new_query.assert_called_once_with()
self.assertFalse(model._update_timestamps.called)
def test_new_instance_returns_instance_wit_attributes_set(self):
model = models.OrmModelStub()
instance = model.new_instance({"name": "john"})
self.assertIsInstance(instance, models.OrmModelStub)
self.assertEqual("john", instance.name)
def test_get_and_set_table(self):
model = models.OrmModelStub()
self.assertEqual("stub", model.get_table())
model.set_table("foo")
self.assertEqual("foo", model.get_table())
def test_get_key_returns_primary_key_value(self):
model = models.OrmModelStub()
model.id = 1
self.assertEqual(1, model.get_key())
self.assertEqual("id", model.get_key_name())
def test_global_guarded(self):
model = models.OrmModelStub()
model.guard(["*"])
self.assertRaises(
MassAssignmentError, model.fill, name="foo", age="bar", foo="bar"
)
def test_fillable(self):
model = models.OrmModelStub()
model.fillable(["name", "age"])
model.fill(name="foo", age=28)
self.assertEqual("foo", model.name)
self.assertEqual(28, model.age)
def test_underscore_properties_are_not_filled(self):
model = models.OrmModelStub()
model.fill(_foo="bar")
self.assertEqual({}, model.get_attributes())
def test_fill_with_dict(self):
model = models.OrmModelStub()
model.fill({"name": "foo", "age": 28})
self.assertEqual("foo", model.name)
self.assertEqual(28, model.age)
