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)