def get_model_references():
"""
Build model reference map
:return: [(model id, [(remote model, remote field), ..], ..]
"""
from noc.lib.nosql import PlainReferenceField, ForeignKeyField
from noc.core.model.fields import DocumentReferenceField
from django.db.models import ForeignKey
def add_ref(model, ref_model, ref_field):
model_id = get_model_id(model)
refs[model_id] += [(ref_model, ref_field)]
refs = defaultdict(list) # model -> [(ref model, ref field)]
for model_id in iter_model_id():
model = get_model(model_id)
if not model:
continue
if is_document(model):
# mongoengine document
for fn in model._fields:
f = model._fields[fn]
if isinstance(f, PlainReferenceField):
add_ref(f.document_type, model_id, fn)
elif isinstance(f, ForeignKeyField):
add_ref(f.document_type, model_id, fn)
else:
# Django model
for f in model._meta.fields:
if isinstance(f, ForeignKey):
add_ref(f.rel.to, model_id, f.name)
elif isinstance(f, DocumentReferenceField):
add_ref(f.document, model_id, f.name)
return [(m, refs[m]) for m in refs]
def handle(self, host=None, port=None, *args, **options):
connect()
db = get_db()
collections = set(db.list_collection_names())
for model_id in iter_model_id():
model = get_model(model_id)
if not model:
self.die("Invalid model: %s" % model_id)
if not is_document(model):
continue
# Rename collections when necessary
legacy_collections = model._meta.get("legacy_collections", [])
for old_name in legacy_collections:
if old_name in collections:
new_name = model._meta["collection"]
self.print("[%s] Renaming %s to %s" %
(model_id, old_name, new_name))
db[old_name].rename(new_name)
break
# Ensure only documents with auto_create_index == False
if model._meta.get("auto_create_index", True):
continue
# Index model
self.index_model(model_id, model)
# Index datastreams
self.index_datastreams()
# Index GridVCS
self.index_gridvcs()
# Index mongo cache
self.index_cache()
# Index datasource cache
self.index_datasource_cache()
# @todo: Detect changes
self.print("OK")
def iter_references():
for model_id in iter_model_id():
model = get_model(model_id)
if not model:
continue
if is_document(model):
# MongoEngine document
for fn in model._fields:
f = model._fields[fn]
if isinstance(f, PlainReferenceField):
yield f.document_type, model_id, fn
elif isinstance(f, ForeignKeyField):
yield f.document_type, model_id, fn
else:
# Django model
for f in model._meta.fields:
if isinstance(f, ForeignKey):
yield f.remote_field.model, model_id, f.name
elif isinstance(f, DocumentReferenceField):
yield f.document, model_id, f.name
def test_iter_model_id():
"""
Check iter_model_id is not empty
"""
assert any(iter_model_id())
def build_modelid(self):
return [{"id": x, "label": x} for x in sorted(iter_model_id())]
def test_iter_model_id():
"""
Check loader.iter_scripts() returns values
"""
total_models = len(list(iter_model_id()))
assert total_models > 0
import operator
# Third-party modules
import pytest
# NOC modules
from noc.models import iter_model_id, get_model, get_model_id, is_document
def test_iter_model_id():
"""
Check loader.iter_scripts() returns values
"""
total_models = len(list(iter_model_id()))
assert total_models > 0
@pytest.fixture(params=iter_model_id())
def model_id(request):
return request.param
@pytest.mark.dependency(name="test_model_loading")
def test_model_loading(model_id):
"""
Check model referred by id can be loaded
:param model_id:
:return:
"""
model = get_model(model_id)
assert model is not None, "Cannot load model %s" % model_id
def get_documents():
for model_id in iter_model_id():
model = get_model(model_id)
if model and is_document(model):
yield model
# See LICENSE for details
# ----------------------------------------------------------------------
# Python modules
from __future__ import absolute_import
# Third-party modules
import pytest
# NOC modules
from noc.models import get_model_id, get_model, iter_model_id
from .util import get_models, get_documents
@pytest.mark.dependency(name="test_model_loading")
@pytest.mark.parametrize("model_id", iter_model_id())
def test_model_loading(model_id):
"""
Check model referred by id can be loaded
:param model_id:
:return:
"""
model = get_model(model_id)
assert model is not None, "Cannot load model %s" % model_id
@pytest.mark.dependency(name="test_model_id", depends=["test_model_loading"])
@pytest.mark.parametrize("model_id", iter_model_id())
def test_model_id(model_id):
"""
Check model has same model_id as referred
