def test_models_are_properly_pulled_and_matched(self):
relation = self._get_relation()
one = flexmock(Model())
one.morph_type = 'morph_type_1'
one.foreign_key = 'foreign_key_1'
two = flexmock(Model())
two.morph_type = 'morph_type_1'
two.foreign_key = 'foreign_key_1'
three = flexmock(Model())
three.morph_type = 'morph_type_2'
three.foreign_key = 'foreign_key_2'
relation.add_eager_constraints([one, two, three])
first_query = flexmock(Builder(flexmock(QueryBuilder(None, QueryGrammar(), None))))
second_query = flexmock(Builder(flexmock(QueryBuilder(None, QueryGrammar(), None))))
first_model = flexmock(Model())
second_model = flexmock(Model())
relation.should_receive('_create_model_by_type').once().with_args('morph_type_1').and_return(first_model)
relation.should_receive('_create_model_by_type').once().with_args('morph_type_2').and_return(second_model)
first_model.should_receive('get_key_name').and_return('id')
second_model.should_receive('get_key_name').and_return('id')
first_model.should_receive('new_query').once().and_return(first_query)
second_model.should_receive('new_query').once().and_return(second_query)
first_query.get_query().should_receive('where_in').once()\
.with_args('id', ['foreign_key_1']).and_return(first_query)
result_one = flexmock()
first_query.should_receive('get').and_return(Collection.make([result_one]))
result_one.should_receive('get_key').and_return('foreign_key_1')
second_query.get_query().should_receive('where_in').once()\
.with_args('id', ['foreign_key_2']).and_return(second_query)
result_two = flexmock()
second_query.should_receive('get').and_return(Collection.make([result_two]))
result_two.should_receive('get_key').and_return('foreign_key_2')
one.should_receive('set_relation').once().with_args('relation', result_one)
two.should_receive('set_relation').once().with_args('relation', result_one)
three.should_receive('set_relation').once().with_args('relation', result_two)
relation.get_eager()
def test_get_does_not_eager_relations_when_no_results_are_returned(self):
flexmock(Builder)
builder = Builder(self.get_mock_query_builder())
builder.should_receive('get_models').with_args(['foo'
]).and_return(['bar'])
builder.should_receive('eager_load_relations').with_args(
['bar']).and_return([])
builder.set_model(self.get_mock_model())
builder.get_model().new_collection = mock.MagicMock(
return_value=Collection([]))
results = builder.get(['foo'])
self.assertEqual([], results.all())
builder.get_model().new_collection.assert_called_with([])
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_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_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_models_are_properly_matched_to_parents(self):
relation = self._get_relation()
result1 = flexmock()
result1.should_receive('get_attribute').with_args('id').and_return(1)
result2 = flexmock()
result2.should_receive('get_attribute').with_args('id').and_return(2)
model1 = OrmBelongsToModelStub()
model1.foreign_key = 1
model2 = OrmBelongsToModelStub()
model2.foreign_key = 2
models = relation.match([model1, model2], Collection([result1, result2]), 'foo')
self.assertEqual(1, models[0].foo.get_attribute('id'))
self.assertEqual(2, models[1].foo.get_attribute('id'))
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_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_first(self):
model = self.get_mock_model()
builder = Builder(self.get_mock_query_builder())
builder.set_model(model)
builder.take = mock.MagicMock(return_value=builder)
builder.get = mock.MagicMock(return_value=Collection(['bar']))
result = builder.first()
self.assertEqual('bar', result)
builder.take.assert_called_once_with(
1
)
builder.get.assert_called_once_with(
['*']
)
def test_sync_syncs_intermediate_table_with_given_list_and_attributes(
self):
flexmock(BelongsToMany)
relation = self._get_relation()
query = flexmock()
query.should_receive("from_").once().with_args("user_role").and_return(
query)
query.should_receive("where").once().with_args("user_id",
1).and_return(query)
mock_query_builder = flexmock()
relation.get_query().should_receive("get_query").and_return(
mock_query_builder)
mock_query_builder.should_receive("new_query").once().and_return(query)
query.should_receive("lists").once().with_args("role_id").and_return(
Collection([1, 2, 3]))
relation.should_receive("attach").once().with_args(
4, {"foo": "bar"}, False)
relation.should_receive("update_existing_pivot").once().with_args(
3, {
"bar": "baz"
}, False).and_return(True)
relation.should_receive("detach").once().with_args([1])
relation.should_receive("touch_if_touching").once()
relation.get_related().should_receive("touches").and_return(False)
relation.get_parent().should_receive("touches").and_return(False)
self.assertEqual(
{
"attached": [4],
"detached": [1],
"updated": [3]
},
relation.sync([2, {
3: {
"bar": "baz"
}
}, {
4: {
"foo": "bar"
}
}]),
)
def test_touch_method_syncs_timestamps(self):
relation = self._get_relation()
relation.get_related().should_receive(
'get_updated_at_column').and_return('updated_at')
now = pendulum.now()
relation.get_related().should_receive('fresh_timestamp').and_return(
now)
relation.get_related().should_receive(
'get_qualified_key_name').and_return('table.id')
relation.get_query().get_query().should_receive('select').once().with_args('table.id')\
.and_return(relation.get_query().get_query())
relation.get_query().should_receive('lists').once().and_return(
Collection([1, 2, 3]))
query = flexmock()
relation.get_related().should_receive('new_query').once().and_return(
query)
query.should_receive('where_in').once().with_args(
'id', [1, 2, 3]).and_return(query)
query.should_receive('update').once().with_args({'updated_at': now})
relation.touch()
def test_sync_syncs_intermediate_table_with_given_list_and_attributes(
self):
flexmock(BelongsToMany)
relation = self._get_relation()
query = flexmock()
query.should_receive('from_').once().with_args('user_role').and_return(
query)
query.should_receive('where').once().with_args('user_id',
1).and_return(query)
mock_query_builder = flexmock()
relation.get_query().should_receive('get_query').and_return(
mock_query_builder)
mock_query_builder.should_receive('new_query').once().and_return(query)
query.should_receive('lists').once().with_args('role_id').and_return(
Collection([1, 2, 3]))
relation.should_receive('attach').once().with_args(
4, {'foo': 'bar'}, False)
relation.should_receive('update_existing_pivot').once().with_args(
3, {
'bar': 'baz'
}, False).and_return(True)
relation.should_receive('detach').once().with_args([1])
relation.should_receive('touch_if_touching').once()
relation.get_related().should_receive('touches').and_return(False)
relation.get_parent().should_receive('touches').and_return(False)
self.assertEqual({
'attached': [4],
'detached': [1],
'updated': [3]
}, relation.sync([2, {
3: {
'bar': 'baz'
}
}, {
4: {
'foo': 'bar'
}
}], ))
def test_push_empty_many_relation(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)
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_touch_method_syncs_timestamps(self):
relation = self._get_relation()
relation.get_related().should_receive(
"get_updated_at_column").and_return("updated_at")
now = pendulum.now()
relation.get_related().should_receive("fresh_timestamp").and_return(
now)
relation.get_related().should_receive(
"get_qualified_key_name").and_return("table.id")
relation.get_query().get_query().should_receive(
"select").once().with_args("table.id").and_return(
relation.get_query().get_query())
relation.get_query().should_receive("lists").once().and_return(
Collection([1, 2, 3]))
query = flexmock()
relation.get_related().should_receive("new_query").once().and_return(
query)
query.should_receive("where_in").once().with_args(
"id", [1, 2, 3]).and_return(query)
query.should_receive("update").once().with_args({"updated_at": now})
relation.touch()
def test_models_are_properly_matched_to_parents(self):
relation = self._get_relation()
result1 = OrmHasOneModelStub()
result1.foreign_key = 1
result2 = OrmHasOneModelStub()
result2.foreign_key = 2
model1 = OrmHasOneModelStub()
model1.id = 1
model2 = OrmHasOneModelStub()
model2.id = 2
model3 = OrmHasOneModelStub()
model3.id = 3
relation.get_query().should_receive('where').with_args('table.foreign_key', '=', 2)
relation.get_query().should_receive('where').with_args('table.foreign_key', '=', 3)
models = relation.match([model1, model2, model3], Collection([result1, result2]), 'foo')
self.assertEqual(1, models[0].foo.foreign_key)
self.assertEqual(2, models[1].foo.foreign_key)
self.assertEqual(None, models[2].foo)
def serialized_json_api_obj(self, records=Collection()):
"""
This method returns an single model or collection of models records
serialized as JSONApi schema obj.
NOTE: Currently just collection of the same model type are supported
"""
result_obj = {}
many = False
schema = None
if isinstance(records, Collection) and not records.is_empty():
many = True
schema = records.first().__class__.schema()
elif callable(getattr(records.__class__, "schema")):
many = False
schema = records.__class__.schema()
if schema:
result_obj = self.__dump_schema(records=records,
schema=schema,
many=many)
return result_obj
def test_relation_is_properly_initialized(self):
relation = self._get_relation()
model = flexmock(Model())
relation.get_related().should_receive('new_collection').replace_with(lambda l=None: Collection(l or []))
model.should_receive('set_relation').once().with_args('foo', Collection)
models = relation.init_relation([model], 'foo')
self.assertEqual([model], models)
