def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('join').at_least().once().with_args('users', 'users.id', '=', 'posts.user_id')
builder.should_receive('where').with_args('users.country_id', '=', 1)
country = flexmock(Model())
country.should_receive('get_key').and_return(1)
country.should_receive('get_foreign_key').and_return('country_id')
user = flexmock(Model())
user.should_receive('get_table').and_return('users')
user.should_receive('get_qualified_key_name').and_return('users.id')
post = flexmock(Model())
post.should_receive('get_table').and_return('posts')
builder.should_receive('get_model').and_return(post)
post.should_receive('new_query').and_return(builder)
user.should_receive('get_key').and_return(1)
user.should_receive('get_created_at_column').and_return('created_at')
user.should_receive('get_updated_at_column').and_return('updated_at')
parent = flexmock(Model())
parent.should_receive('get_attribute').with_args('id').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
parent.should_receive('new_query').and_return(builder)
return HasManyThrough(builder, country, user, 'country_id', 'user_id')
def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive("join").at_least().once().with_args(
"users", "users.id", "=", "posts.user_id")
builder.should_receive("where").with_args("users.country_id", "=", 1)
country = flexmock(Model())
country.should_receive("get_key").and_return(1)
country.should_receive("get_foreign_key").and_return("country_id")
user = flexmock(Model())
user.should_receive("get_table").and_return("users")
user.should_receive("get_qualified_key_name").and_return("users.id")
post = flexmock(Model())
post.should_receive("get_table").and_return("posts")
builder.should_receive("get_model").and_return(post)
post.should_receive("new_query").and_return(builder)
user.should_receive("get_key").and_return(1)
user.should_receive("get_created_at_column").and_return("created_at")
user.should_receive("get_updated_at_column").and_return("updated_at")
parent = flexmock(Model())
parent.should_receive("get_attribute").with_args("id").and_return(1)
parent.should_receive("get_created_at_column").and_return("created_at")
parent.should_receive("get_updated_at_column").and_return("updated_at")
parent.should_receive("new_query").and_return(builder)
return HasManyThrough(builder, country, user, "country_id", "user_id")
def _get_relation_arguments(self):
flexmock(Model).should_receive("_boot_columns").and_return(["name"])
parent = flexmock(Model())
parent.should_receive("get_key").and_return(1)
parent.should_receive("get_created_at_column").and_return("created_at")
parent.should_receive("get_updated_at_column").and_return("updated_at")
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive("get_query").and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive("get_model").and_return(related)
related.should_receive("new_query").and_return(builder)
related.should_receive("get_key_name").and_return("id")
related.should_receive("get_table").and_return("roles")
related.should_receive("new_pivot").replace_with(
lambda *args: Pivot(*args))
builder.get_query().should_receive("join").at_least().once().with_args(
"user_role", "roles.id", "=", "user_role.role_id")
builder.should_receive("where").at_least().once().with_args(
"user_role.user_id", "=", 1)
return builder, parent, "user_role", "user_id", "role_id", "relation_id"
def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('join').at_least().once().with_args('users', 'users.id', '=', 'posts.user_id')
builder.should_receive('where').with_args('users.country_id', '=', 1)
country = flexmock(Model())
country.should_receive('get_key').and_return(1)
country.should_receive('get_foreign_key').and_return('country_id')
user = flexmock(Model())
user.should_receive('get_table').and_return('users')
user.should_receive('get_qualified_key_name').and_return('users.id')
post = flexmock(Model())
post.should_receive('get_table').and_return('posts')
builder.should_receive('get_model').and_return(post)
post.should_receive('new_query').and_return(builder)
user.should_receive('get_key').and_return(1)
user.should_receive('get_created_at_column').and_return('created_at')
user.should_receive('get_updated_at_column').and_return('updated_at')
parent = flexmock(Model())
parent.should_receive('get_attribute').with_args('id').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
parent.should_receive('new_query').and_return(builder)
return HasManyThrough(builder, country, user, 'country_id', 'user_id')
def _get_relation(self):
flexmock(Builder)
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive("join").at_least().once().with_args(
"users", "users.id", "=", "posts.user_id"
)
builder.should_receive("where").with_args("users.country_id", "=", 1)
country = flexmock(Model())
country.should_receive("get_key").and_return(1)
country.should_receive("get_foreign_key").and_return("country_id")
user = flexmock(Model())
user.should_receive("get_table").and_return("users")
user.should_receive("get_qualified_key_name").and_return("users.id")
post = flexmock(Model())
post.should_receive("get_table").and_return("posts")
builder.should_receive("get_model").and_return(post)
post.should_receive("new_query").and_return(builder)
user.should_receive("get_key").and_return(1)
user.should_receive("get_created_at_column").and_return("created_at")
user.should_receive("get_updated_at_column").and_return("updated_at")
parent = flexmock(Model())
parent.should_receive("get_attribute").with_args("id").and_return(1)
parent.should_receive("get_created_at_column").and_return("created_at")
parent.should_receive("get_updated_at_column").and_return("updated_at")
parent.should_receive("new_query").and_return(builder)
return HasManyThrough(builder, country, user, "country_id", "user_id")
def _get_relation_arguments(self):
flexmock(Model).should_receive('_boot_columns').and_return(['name'])
parent = flexmock(Model())
parent.should_receive('get_key').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('new_query').and_return(builder)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('roles')
related.should_receive('new_pivot').replace_with(
lambda *args: Pivot(*args))
builder.get_query().should_receive('join').at_least().once().with_args(
'user_role', 'roles.id', '=', 'user_role.role_id')
builder.should_receive('where').at_least().once().with_args(
'user_role.user_id', '=', 1)
return builder, parent, 'user_role', 'user_id', 'role_id', 'relation_id'
def _get_relation_arguments(self):
parent = flexmock(Model())
parent.should_receive('get_morph_name').and_return(
parent.__class__.__name__)
parent.should_receive('get_key').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
query = flexmock(
QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(),
QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('tags')
related.should_receive('get_morph_name').and_return(
parent.__class__.__name__)
builder.get_query().should_receive('join').once().with_args(
'taggables', 'tags.id', '=', 'taggables.tag_id')
builder.should_receive('where').once().with_args(
'taggables.taggable_id', '=', 1)
builder.should_receive('where').once().with_args(
'taggables.taggable_type', parent.__class__.__name__)
return builder, parent, 'taggable', 'taggables', 'taggable_id', 'tag_id', 'relation_name', False
def test_push_one_relation(self):
related1 = flexmock(Model())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'related1'}, 'id').and_return(2)
related1.should_receive('new_query').once().and_return(builder)
related1.should_receive('_update_timestamps').once()
related1.name = 'related1'
related1.set_exists(False)
model = flexmock(Model())
model.should_receive('resolve_connection').and_return(MockConnection().prepare_mock())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'john'}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
model.set_relation('relation_one', related1)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(2, model.relation_one.id)
self.assertTrue(model.relation_one.exists)
self.assertEqual(2, related1.id)
self.assertTrue(related1.exists)
def test_push_one_relation(self):
flexmock(Builder)
related1 = flexmock(Model())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'related1'}, 'id').and_return(2)
related1.should_receive('new_query').once().and_return(builder)
related1.should_receive('_update_timestamps').once()
related1.name = 'related1'
related1.set_exists(False)
model = flexmock(Model())
model.should_receive('resolve_connection').and_return(MockConnection().prepare_mock())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'john'}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
model.set_relation('relation_one', related1)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(2, model.relation_one.id)
self.assertTrue(model.relation_one.exists)
self.assertEqual(2, related1.id)
self.assertTrue(related1.exists)
def test_find_by_method(self):
builder = Builder(self.get_mock_query_builder())
builder.set_model(self.get_mock_model())
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value='baz')
result = builder.find_by('foo', 'bar', ['column'])
builder.get_query().where.assert_called_once_with('foo', '=', 'bar')
self.assertEqual('baz', result)
def test_find_method(self):
builder = Builder(self.get_mock_query_builder())
builder.set_model(self.get_mock_model())
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value="baz")
result = builder.find("bar", ["column"])
builder.get_query().where.assert_called_once_with(
"foo_table.foo", "=", "bar")
self.assertEqual("baz", result)
def test_find_method(self):
builder = Builder(self.get_mock_query_builder())
builder.set_model(self.get_mock_model())
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value='baz')
result = builder.find('bar', ['column'])
builder.get_query().where.assert_called_once_with(
'foo_table.foo', '=', 'bar'
)
self.assertEqual('baz', result)
def test_relation_count_query_can_be_built(self):
relation = self._get_relation()
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('select').once()
relation.get_parent().should_receive('get_table').and_return('table')
builder.should_receive('where').once().with_args('table.foreign_key', '=', QueryExpression)
parent_query = flexmock(QueryBuilder(None, None, None))
relation.get_query().should_receive('get_query').and_return(parent_query)
grammar = flexmock()
parent_query.should_receive('get_grammar').once().and_return(grammar)
grammar.should_receive('wrap').once().with_args('table.id')
relation.get_relation_count_query(builder, builder)
def test_relation_count_query_can_be_built(self):
relation = self._get_relation()
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive('select').once()
relation.get_parent().should_receive('get_table').and_return('table')
builder.should_receive('where').once().with_args('table.foreign_key', '=', QueryExpression)
parent_query = flexmock(QueryBuilder(None, None, None))
relation.get_query().should_receive('get_query').and_return(parent_query)
grammar = flexmock()
parent_query.should_receive('get_grammar').once().and_return(grammar)
grammar.should_receive('wrap').once().with_args('table.id')
relation.get_relation_count_query(builder, builder)
def test_find_by_or_fail_raises_model_not_found_exception(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value=None)
self.assertRaises(ModelNotFound, builder.find_by_or_fail, 'foo', 'bar',
['column'])
builder.get_query().where.assert_called_once_with('foo', '=', 'bar')
builder.first.assert_called_once_with(['column'])
def test_push_no_relations(self):
model = flexmock(Model())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'john'}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
def test_find_or_fail_raises_model_not_found_exception(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value=None)
self.assertRaises(ModelNotFound, builder.find_or_fail, "bar",
["column"])
builder.get_query().where.assert_called_once_with(
"foo_table.foo", "=", "bar")
builder.first.assert_called_once_with(["column"])
def test_find_or_fail_with_many_raises_model_not_found_exception(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where_in = mock.MagicMock()
builder.get = mock.MagicMock(return_value=Collection([1]))
self.assertRaises(ModelNotFound, builder.find_or_fail, [1, 2],
["column"])
builder.get_query().where_in.assert_called_once_with(
"foo_table.foo", [1, 2])
builder.get.assert_called_once_with(["column"])
def test_find_or_new_model_found(self):
model = self.get_mock_model()
model.find_or_new = mock.MagicMock(return_value="baz")
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value="baz")
expected = model.find_or_new("bar", ["column"])
result = builder.find("bar", ["column"])
builder.get_query().where.assert_called_once_with(
"foo_table.foo", "=", "bar")
self.assertEqual(expected, result)
def test_find_or_new_model_found(self):
model = self.get_mock_model()
model.find_or_new = mock.MagicMock(return_value='baz')
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value='baz')
expected = model.find_or_new('bar', ['column'])
result = builder.find('bar', ['column'])
builder.get_query().where.assert_called_once_with(
'foo_table.foo', '=', 'bar')
self.assertEqual(expected, result)
def test_find_with_many(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where_in = mock.MagicMock()
builder.get = mock.MagicMock(return_value="baz")
result = builder.find([1, 2], ["column"])
self.assertEqual("baz", result)
builder.get_query().where_in.assert_called_once_with(
"foo_table.foo", [1, 2])
builder.get.assert_called_once_with(["column"])
def test_relation_count_query_can_be_built(self):
relation = self._get_relation()
query = flexmock(QueryBuilder(None, QueryGrammar(), None))
builder = Builder(query)
builder.get_query().should_receive("select").once()
relation.get_parent().should_receive("get_table").and_return("table")
builder.should_receive("where").once().with_args(
"table.foreign_key", "=", QueryExpression)
parent_query = flexmock(QueryBuilder(None, None, None))
relation.get_query().should_receive("get_query").and_return(
parent_query)
grammar = flexmock()
parent_query.should_receive("get_grammar").once().and_return(grammar)
grammar.should_receive("wrap").once().with_args("table.id")
relation.get_relation_count_query(builder, builder)
def test_fresh_method(self):
model = flexmock(OrmModelStub())
model.id = 1
model.set_exists(True)
builder = flexmock(Builder)
query = Builder(flexmock(QueryBuilder(None, None, None)))
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_find_or_new_model_not_found(self):
model = self.get_mock_model()
model.find_or_new = mock.MagicMock(return_value=self.get_mock_model())
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value=None)
result = model.find_or_new("bar", ["column"])
find_result = builder.find("bar", ["column"])
builder.get_query().where.assert_called_once_with(
"foo_table.foo", "=", "bar")
self.assertIsNone(find_result)
self.assertIsInstance(result, Model)
def test_find_or_new_model_found(self):
model = self.get_mock_model()
model.find_or_new = mock.MagicMock(return_value='baz')
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value='baz')
expected = model.find_or_new('bar', ['column'])
result = builder.find('bar', ['column'])
builder.get_query().where.assert_called_once_with(
'foo_table.foo', '=', 'bar'
)
self.assertEqual(expected, result)
def test_push_empty_many_relation(self):
flexmock(Builder)
model = flexmock(Model())
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
builder = Builder(query)
builder.get_query().should_receive('insert_get_id').once().with_args({'name': 'john'}, 'id').and_return(1)
model.should_receive('new_query').once().and_return(builder)
model.should_receive('_update_timestamps').once()
model.name = 'john'
model.set_exists(False)
model.set_relation('relation_many', Collection([]))
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(0, len(model.relation_many))
def test_find_or_new_model_not_found(self):
model = self.get_mock_model()
model.find_or_new = mock.MagicMock(return_value=self.get_mock_model())
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value=None)
result = model.find_or_new('bar', ['column'])
find_result = builder.find('bar', ['column'])
builder.get_query().where.assert_called_once_with(
'foo_table.foo', '=', 'bar'
)
self.assertIsNone(find_result)
self.assertIsInstance(result, Model)
def test_find_with_many(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where_in = mock.MagicMock()
builder.get = mock.MagicMock(return_value='baz')
result = builder.find([1, 2], ['column'])
self.assertEqual('baz', result)
builder.get_query().where_in.assert_called_once_with(
'foo_table.foo', [1, 2]
)
builder.get.assert_called_once_with(
['column']
)
def test_push_one_relation(self):
related1 = flexmock(Model())
query = flexmock(
QueryBuilder(
MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()
)
)
builder = Builder(query)
builder.get_query().should_receive("insert_get_id").once().with_args(
{"name": "related1"}, "id"
).and_return(2)
related1.should_receive("new_query").once().and_return(builder)
related1.should_receive("_update_timestamps").once()
related1.name = "related1"
related1.set_exists(False)
model = flexmock(Model())
model.should_receive("resolve_connection").and_return(
MockConnection().prepare_mock()
)
query = flexmock(
QueryBuilder(
MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()
)
)
builder = Builder(query)
builder.get_query().should_receive("insert_get_id").once().with_args(
{"name": "john"}, "id"
).and_return(1)
model.should_receive("new_query").once().and_return(builder)
model.should_receive("_update_timestamps").once()
model.name = "john"
model.set_exists(False)
model.set_relation("relation_one", related1)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
self.assertEqual(2, model.relation_one.id)
self.assertTrue(model.relation_one.exists)
self.assertEqual(2, related1.id)
self.assertTrue(related1.exists)
def _get_relation_arguments(self):
parent = flexmock(Model())
parent.should_receive("get_morph_name").and_return(parent.__class__.__name__)
parent.should_receive("get_key").and_return(1)
parent.should_receive("get_created_at_column").and_return("created_at")
parent.should_receive("get_updated_at_column").and_return("updated_at")
query = flexmock(
QueryBuilder(
MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()
)
)
flexmock(Builder)
builder = Builder(query)
builder.should_receive("get_query").and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive("get_model").and_return(related)
related.should_receive("get_key_name").and_return("id")
related.should_receive("get_table").and_return("tags")
related.should_receive("get_morph_name").and_return(parent.__class__.__name__)
builder.get_query().should_receive("join").once().with_args(
"taggables", "tags.id", "=", "taggables.tag_id"
)
builder.should_receive("where").once().with_args(
"taggables.taggable_id", "=", 1
)
builder.should_receive("where").once().with_args(
"taggables.taggable_type", parent.__class__.__name__
)
return (
builder,
parent,
"taggable",
"taggables",
"taggable_id",
"tag_id",
"relation_name",
False,
)
def test_push_no_relations(self):
model = flexmock(Model())
query = flexmock(
QueryBuilder(
MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()
)
)
builder = Builder(query)
builder.get_query().should_receive("insert_get_id").once().with_args(
{"name": "john"}, "id"
).and_return(1)
model.should_receive("new_query").once().and_return(builder)
model.should_receive("_update_timestamps").once()
model.name = "john"
model.set_exists(False)
self.assertTrue(model.push())
self.assertEqual(1, model.id)
self.assertTrue(model.exists)
def test_find_or_fail_with_many_raises_model_not_found_exception(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where_in = mock.MagicMock()
builder.get = mock.MagicMock(return_value=Collection([1]))
self.assertRaises(
ModelNotFound,
builder.find_or_fail,
[1, 2],
['column']
)
builder.get_query().where_in.assert_called_once_with(
'foo_table.foo', [1, 2]
)
builder.get.assert_called_once_with(
['column']
)
def test_find_or_fail_raises_model_not_found_exception(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.get_query().where = mock.MagicMock()
builder.first = mock.MagicMock(return_value=None)
self.assertRaises(
ModelNotFound,
builder.find_or_fail,
'bar',
['column']
)
builder.get_query().where.assert_called_once_with(
'foo_table.foo', '=', 'bar'
)
builder.first.assert_called_once_with(
['column']
)
def _get_relation_arguments(self):
parent = flexmock(Model())
parent.should_receive('get_morph_name').and_return(parent.__class__.__name__)
parent.should_receive('get_key').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('tags')
related.should_receive('get_morph_name').and_return(parent.__class__.__name__)
builder.get_query().should_receive('join').once().with_args('taggables', 'tags.id', '=', 'taggables.tag_id')
builder.should_receive('where').once().with_args('taggables.taggable_id', '=', 1)
builder.should_receive('where').once().with_args('taggables.taggable_type', parent.__class__.__name__)
return builder, parent, 'taggable', 'taggables', 'taggable_id', 'tag_id', 'relation_name', False
def _get_relation_arguments(self):
flexmock(Model).should_receive('_boot_columns').and_return(['name'])
parent = flexmock(Model())
parent.should_receive('get_key').and_return(1)
parent.should_receive('get_created_at_column').and_return('created_at')
parent.should_receive('get_updated_at_column').and_return('updated_at')
query = flexmock(QueryBuilder(MockConnection().prepare_mock(), QueryGrammar(), QueryProcessor()))
flexmock(Builder)
builder = Builder(query)
builder.should_receive('get_query').and_return(query)
related = flexmock(Model())
builder.set_model(related)
builder.should_receive('get_model').and_return(related)
related.should_receive('new_query').and_return(builder)
related.should_receive('get_key_name').and_return('id')
related.should_receive('get_table').and_return('roles')
related.should_receive('new_pivot').replace_with(lambda *args: Pivot(*args))
builder.get_query().should_receive('join').at_least().once().with_args('user_role', 'roles.id', '=', 'user_role.role_id')
builder.should_receive('where').at_least().once().with_args('user_role.user_id', '=', 1)
return builder, parent, 'user_role', 'user_id', 'role_id', 'relation_id'
def test_get_models_hydrates_models(self):
builder = Builder(self.get_mock_query_builder())
records = [{'name': 'john', 'age': 26}, {'name': 'jane', 'age': 28}]
builder.get_query().get = mock.MagicMock(return_value=records)
model = self.get_mock_model()
builder.set_model(model)
model.get_connection_name = mock.MagicMock(
return_value='foo_connection')
model.hydrate = mock.MagicMock(return_value=Collection(['hydrated']))
models = builder.get_models(['foo'])
self.assertEqual(models.all(), ['hydrated'])
model.get_table.assert_called_once_with()
model.get_connection_name.assert_called_once_with()
model.hydrate.assert_called_once_with(records, 'foo_connection')
def test_get_models_hydrates_models(self):
builder = Builder(self.get_mock_query_builder())
records = [{
'name': 'john', 'age': 26
}, {
'name': 'jane', 'age': 28
}]
builder.get_query().get = mock.MagicMock(return_value=records)
model = self.get_mock_model()
builder.set_model(model)
model.get_connection_name = mock.MagicMock(return_value='foo_connection')
model.hydrate = mock.MagicMock(return_value=Collection(['hydrated']))
models = builder.get_models(['foo'])
self.assertEqual(models.all(), ['hydrated'])
model.get_table.assert_called_once_with()
model.get_connection_name.assert_called_once_with()
model.hydrate.assert_called_once_with(
records, 'foo_connection'
)
def test_get_models_hydrates_models(self):
builder = Builder(self.get_mock_query_builder())
records = Collection([{
"name": "john",
"age": 26
}, {
"name": "jane",
"age": 28
}])
builder.get_query().get = mock.MagicMock(return_value=records)
model = self.get_mock_model()
builder.set_model(model)
model.get_connection_name = mock.MagicMock(
return_value="foo_connection")
model.hydrate = mock.MagicMock(return_value=Collection(["hydrated"]))
models = builder.get_models(["foo"])
self.assertEqual(models.all(), ["hydrated"])
model.get_table.assert_called_once_with()
model.get_connection_name.assert_called_once_with()
model.hydrate.assert_called_once_with(records, "foo_connection")