Resolves conflicts with last merge

lodel/leapi/datahandlers/base_classes.py

 
 ## @package lodel.leapi.datahandlers.base_classes Define all base/abstract class for data handlers
 #
-# Contains custom exceptions too
+# Contains custom exceptions too
 
 import copy
 import importlib
 LodelContext.expose_modules(globals(), {
     'lodel.exceptions': ['LodelException', 'LodelExceptions',
         'LodelFatalError', 'DataNoneValid', 'FieldValidationError'],
+    'lodel.leapi.datahandlers.exceptions': ['LodelDataHandlerConsistencyException', 'LodelDataHandlerException'],
     'lodel.logger': 'logger'})
 
 
     ##@brief Stores the DataHandler childs classes indexed by name
     _base_handlers = None
     ##@brief Stores custom datahandlers classes indexed by name
-    # @todo do it ! (like plugins, register handlers... blablabla)
+    # @todo do it ! (like plugins, register handlers... blablabla)
     __custom_handlers = dict()
 
     help_text = 'Generic Field Data Handler'
                     logger.warning('Object referenced does not exist')
                     return False
         return True
+    
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@throw NotImplementedError
+    def get_referenced(self, value):
+        raise NotImplementedError
 
 
 ##@brief This class represent a data_handler for single reference to another object
         #    raise FieldValidationError("List or string expected for a set field")
         return value
 
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@return A LeObject child class instance
+    #@throw LodelDataHandlerConsistencyException if no referenced object found
+    def get_referenced(self, value):
+        for leo_cls in self.linked_classes:
+            res = leo_cls.get_from_uid(value)
+            if res is not None:
+                return res
+        raise LodelDataHandlerConsistencyException("Unable to find \
+referenced object with uid %s" % value)
 
 
 ##@brief This class represent a data_handler for multiple references to another object
             raise FieldValidationError("MultipleRef have for invalid values [%s]  :" % (",".join(error_list)))
         return new_val
 
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@return A list of LeObject child class instance
+    #@throw LodelDataHandlerConsistencyException if some referenced objects
+    #were not found
+    def get_referenced(self, values):
+        if values is None or len(values) == 0:
+            return list()
+        left = set(values)
+        values = set(values)
+        res = list()
+        for leo_cls in self.linked_classes:
+            uidname = leo_cls.uid_fieldname()[0] #MULTIPLE UID BROKEN HERE
+            tmp_res = leo_cls.get(('%s in (%s)' % (uidname, ','.join(
+                [str(l) for l in left]))))
+            left ^= set(( leo.uid() for leo in tmp_res))
+            res += tmp_res
+            if len(left) == 0:
+                return res
+        raise LodelDataHandlerConsistencyException("Unable to find \
+some referenced objects. Followinf uid were not found : %s" % ','.join(left))
 
 ## @brief Class designed to handle datas access will fieldtypes are constructing datas
 #@ingroup lodel2_datahandlers

lodel/leapi/datahandlers/exceptions.py

 def LodelDataHandlerException(Exception):
     pass
+
+def LodelDataHandlerConsistencyException(LodelDataHandlerException):
+    pass

lodel/leapi/leobject.py

     #@todo broken multiple UID
     @classmethod
     def get_from_uid(cls, uid):
+        if cls.uid_fieldname() is None:
+            raise LodelFatalError(
+                "No uid defined for class %s" % cls.__name__)
         uidname = cls.uid_fieldname()[0] #Brokes composed UID
         res = cls.get([(uidname,'=', uid)])
+        
+        #dedoublonnage vu que query ou la datasource est bugué
+        if len(res) > 1:
+            res_cp = res
+            res = []
+            while len(res_cp) > 0:
+                cur_res = res_cp.pop()
+                if cur_res.uid() in [ r.uid() for r in res_cp]:
+                    logger.error("DOUBLON detected in query results !!!")
+                else:
+                    res.append(cur_res)
         if len(res) > 1:
             raise LodelFatalError("Get from uid returned more than one \
 object ! For class %s with uid value = %s" % (cls, uid))

lodel/maindoc.py

+#-*- coding: utf-8 -*-
+
+## @mainpage
+#
+# @section lodel_general_description General Description
+# Lodel is a web publishing system which is configurable to one's specific needs. It is a member of the content management systems' category.
+#
+# In its 2.0 version, it is composed from a main package, called "lodel" which contains all of its core packages and modules.
+#
+# @section lodel_core_components Core Components
+# The application contains the following packages in its core :
+#
+# - lodel.auth : the authentication system used to deal with the users' sessions
+# - lodel.editorial_model : a package containing all the tools to read/write/update an editorial model
+# - lodel.leapi : the main API that will be used to access the documents' data
+# - lodel.plugin : a plugin manager (with modules to deal with the hooks, the scripts, the options, etc ... brought in by each plugin)
+# - lodel.plugins : this package is used to store all the plugins that are added in Lodel
+# - lodel.settings : the settings management tools
+# - lodel.utils : several small tools that are useful and common to several core modules
+#
+# Aside from that, there are core modules :
+# - lodel.context : the context manager (used for the multisite functionality)
+# - lodel.logger : a global logging tool
+#
+# @section one_code_and_multiple_websites One code and multiple websites
+# Lodel can be used to manage one or many websites using the same core code. Each website will have its own activated plugins,
+# editorial model options and settings, all managed by the context manager.
+#

lodel/plugins/dummy/main.py

 
 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
-    'lodel.plugin': ['LodelHook', 'CustomMethod']})
+    'lodel.plugin': ['LodelHook', 'CustomMethod'],
+    'lodel.settings' : 'settings'})
 
 @LodelHook('leapi_get_post')
 @LodelHook('leapi_update_pre')
 @LodelHook('leapi_insert_pre')
 @LodelHook('leapi_insert_post')
 def dummy_callback(hook_name, caller, payload):
-    if Lodel.settings.Settings.debug:
+    if settings.Settings.debug:
         print("\tHook %s\tcaller %s with %s" % (hook_name, caller, payload))
     return payload
 

lodel/plugins/mongodb_datasource/datasource.py

         return list(res.inserted_ids)
     
     ##@brief Update backref giving an action
-    #@param target leObject child class
-    #@param filters
-    #@param relational_filters,
-    #@param new_datas None | dict : optional new datas if None mean we are deleting
-    #@param old_datas_l None | list : if None fetch old datas from db (usefull
+    # @param target leObject child class
+    # @param filters
+    # @param relational_filters
+    # @param new_datas None | dict : optional new datas if None mean we are deleting
+    # @param old_datas_l None | list : if None fetch old datas from db (usefull
     #when modifications are made on instance before updating backrefs)
-    #@return nothing (for the moment
+    # @return nothing (for the moment
     def __update_backref_filtered(self, target,
             filters, relational_filters, new_datas = None, old_datas_l = None):
         #Getting all the UID of the object that will be deleted in order
             self.__update_backref(
                 target, old_datas[uidname], old_datas, new_datas)
 
-    ##@brief Update back references of an object
-    #@ingroup plugin_mongodb_bref_op
+    ## @brief Update back references of an object
+    # @ingroup plugin_mongodb_bref_op
     #
     #old_datas and new_datas arguments are set to None to indicate 
     #insertion or deletion. Calls examples :
-    #@par LeObject insert __update backref call
-    #<pre>
+    # @par LeObject insert __update backref call
+    # <pre>
     #Insert(datas):
     #  self.make_insert(datas)
     #  self.__update_backref(self.__class__, None, datas)
-    #</pre>
-    #@par LeObject delete __update backref call
+    # </pre>
+    # @par LeObject delete __update backref call
     #Delete()
     #  old_datas = self.datas()
     #  self.make_delete()
     #  self.__update_backref(self.__class__, old_datas, None)
-    #@par LeObject update __update_backref call
-    #<pre>
+    # @par LeObject update __update_backref call
+    # <pre>
     #Update(new_datas):
     #  old_datas = self.datas()
     #  self.make_udpdate(new_datas)
     #  self.__update_backref(self.__class__, old_datas, new_datas)
-    #</pre>
+    # </pre>
     #
-    #@param target LeObject child classa
-    #@param tuid mixed : The target UID (the value that will be inserted in
+    # @param target LeObject child classa
+    # @param tuid mixed : The target UID (the value that will be inserted in
     #back references)
-    #@param old_datas dict : datas state before update
-    #@param new_datas dict : datas state after the update process
-    #retun None
+    # @param old_datas dict : datas state before update
+    # @param new_datas dict : datas state after the update process
+    # retun None
     def __update_backref(self, target, tuid, old_datas, new_datas):
         #upd_dict is the dict that will allow to run updates in an optimized
         #way (or try to help doing it)
         #
-        #It's struct looks like :
+        #Its structure looks like :
         # { LeoCLASS : {
         #       UID1: (
         #           LeoINSTANCE,
     #@param fdh DataHandler : the source Reference DataHandler
     #@param tuid mixed : the uid of the Leo that make reference to the backref
     #@param bref_infos tuple : as returned by __bref_get_check() method
-    #@param old mixed : (optional **values) the old value
-    #@param new mixed : (optional **values) the new value
+    #@param values dict : contains the old and new values (optional) with the "old" and "new" keys
     #@return the new back reference field value
     def __back_ref_upd_one_value(self, fname, fdh, tuid, bref_infos, **values):
         bref_cls, bref_leo, bref_dh, bref_val = bref_infos
     #MongoDbDatasource::_connections static attribute
     #@param username str
     #@param password str
+    #@param db_name str : database name
     #@param ro bool : If True the Datasource is for read only, else the
     def __connect(self, username, password, db_name, ro):
         conn_string = connection_string(
     
     ##@brief Convert lodel2 filters to pymongo conditions
     #@param filters list : list of lodel filters
+    #@param target Datahandler : The datahandler to use to cast the value in the correct type
     #@return dict representing pymongo conditions
     @classmethod
     def __filters2mongo(cls, filters, target):
     #Convertion is done using MongoDbDatasource::lodel2mongo_op_map
     #@param op str : take value in LeFilteredQuery::_query_operators
     #@param value mixed : the value
+    #@param dhdl DataHandler: datahandler used to cast the values before sending them to the database
     #@return a tuple(mongo_op, mongo_value)
     @classmethod
     def __op_value_conv(cls, op, value, dhdl):
     ##@brief Correct some datas before giving them to pymongo
     #
     #For example sets has to be casted to lise
+    #@param cls
     #@param datas
     #@return datas
     @classmethod

lodel/plugins/webui/templates/listing/show_object.html

 {% extends "base.html" %}
+{% import 'macros/show_object.html' as show_object %}
 {% import 'components/components.html' as components %}
 {% set my_class = leapi.name2class(classname) %}
-{% set uidfield = my_class.uid_fieldname()[0] %}
-{% set objects = my_class.get(('%s = %s') % (uidfield, lodel_id)) %}
-{% set obj = objects.pop() %}
+{% set obj = my_class.get_from_uid(lodel_id) %}
+{% if obj is none %}
+    ERROR <!-- conception failure, the controller should test this before calling the template -->
+{% endif %}
 {% if my_class.is_abstract() %}
 {% set classname = obj.data('classname') %}
 {% set my_class = my_class.name2class(classname) %}
 {% endif %}
 {% block title %}Object {{ lodel_id }} {% endblock %}
-{% import "components/components.html" as components %}
 {% block content %}
 <ol class="breadcrumb">
   <li><a href="/{{ root_url }}/">Home</a></li>
   <li class="active">{{ lodel_id }}</li>
 </ol>
 <h1 class="h1_lodel">Lodel 2 - {{ classname }} with uid {{ lodel_id }}</h1>
-<ul>
-    <!-- To get a component HTML code, it is necessary to call : components.<macro_name>(args) -->
-    {% for fieldname, fieldvalue in obj.fields(include_ro = True).items() %}
-        {% if fieldvalue is not none %}
-           {% if fieldvalue.base_type == 'ref' %}
-                {% if obj.data(fieldname) is iterable %}
-                    <li>{{ fieldname }}
-                    {% set l_classe = fieldvalue.allowed_classes[0] %}
-                        <ul>
-                    {% for rel in obj.data(fieldname) %}
-                            {% set casttype = l_classe.data_handler(l_classe.uid_fieldname()[0]).cast_type %}
-                            {% set rel2 = casttype(rel) %}
-                            <li><a href="show_object?classname={{ l_classe.__name__ }}&lodel_id={{ rel2 }}" >{{ rel2 }}</a></li>
-                    {% endfor %}
-                        </ul></li>
-                {% elif obj.data(fieldname) is not none %}
-                        {% set l_classe = fieldvalue.allowed_classes[0] %}
-                         {% set casttype = l_classe.data_handler(l_classe.uid_fieldname()[0]).cast_type %}
-                            {% set rel2 = casttype(obj.data(fieldname)) %}
-                            <li>{{ fieldname }} : <a href="show_object?classname={{ l_classe.__name__ }}&lodel_id={{ rel2 }}" >{{ obj.data(fieldname) }} </a></li>
-                {% endif %}
-            {% else %}
-                <li> {{ fieldname }} : {{ obj.data(fieldname) }} </li>
-            {% endif %}
-        {% endif %}
-    {% endfor %}
-</ul>
+    {{ show_object.object_ul(obj) }}
 {% endblock %}

lodel/plugins/webui/templates/listing/show_object_detailled.html

 {% extends "base.html" %}
+{% import 'macros/show_object.html' as show_object %}
 {% import 'components/components.html' as components %}
 {% import "listing/display_obj.html" as edit %}
 {% set my_class = leapi.name2class(classname) %}
+{% set obj = my_class.get_from_uid(lodel_id) %}
+{% if obj is none %}
+    ERROR <!-- conception failure, the controller should test this before calling the template -->
+{% endif %}
 {% set uidfield = my_class.uid_fieldname()[0] %}
 {% set objects = my_class.get(('%s = %s') % (uidfield, lodel_id)) %}
 {% set obj = objects.pop() %}
   <li class="active">{{ lodel_id }}</li>
 </ol>
 <h1 class="h1_lodel">Lodel 2 - {{ classname }} with uid {{ lodel_id }}</h1>
-<ul>
-    <!-- To get a component HTML code, it is necessary to call : components.<macro_name>(args) -->
-    {% for fieldname, fieldvalue in obj.fields(include_ro = True).items() %}
-        {% if fieldvalue is not none %}
-           {% if fieldvalue.base_type == 'ref' %}
-                {% if obj.data(fieldname) is iterable %}
-                    <li>{{ fieldname }}
-                    {% set l_classe = fieldvalue.allowed_classes[0] %}
-                        <ul>
-                    {% set linked_objs=l_classe.get(("%s in (%s)") % (l_classe.uid_fieldname()[0], obj.data(fieldname)|join(','))) %}
-                    {% for linked_obj in linked_objs %}
-                            {{ edit.display(linked_obj) }}
-                            <br/>
-                    {% endfor %}
-                        </ul></li>
-                {% elif obj.data(fieldname) is not none %}
-                    <li>{{ fieldname }}
-                        <ul>
-                        {% set l_classe = fieldvalue.allowed_classes[0] %}
-                        {% set linked_objs=l_classe.get(("%s = %s") % (l_classe.uid_fieldname()[0], obj.data(fieldname))) %}
-                        {{ edit.display(linked_objs.pop()) }}
-                        <br/>
-                        </ul>
-                    </li>
-                {% endif %}
-            {% else %}
-                <li> {{ fieldname }} : {{ obj.data(fieldname) }} </li>
-            {% endif %}
-        {% endif %}
-    {% endfor %}
-</ul>
+    {{ show_object.object_ul(obj, 2) }}
 {% endblock %}

lodel/plugins/webui/templates/macros/show_object.html

+<!-- Produce a <li></li> with objects informations -->
+{% macro object_ul(leo, max_depth = 0, exclude = []) -%}
+    <ul>
+        {% if max_depth <= 0 %}
+            <!-- No need to go deeper -->
+            {% for fname, fvalue in leo.datas(True).items() %}
+                <li><em>{{ fname }}</em> : {{fvalue}}</li>
+            {%endfor%}
+        {% else %}
+            {% for fname in leo.fieldnames(True) %}
+                {% set fvalue = leo.data(fname) %}
+                {% set fdh = leo.data_handler(fname) %}
+                {% if fvalue is not none and fdh.is_reference() %}
+                    {% if fdh.is_singlereference() %}
+                        {% set referenced = fdh.get_referenced(fvalue) %}
+                        {% if (referenced.__class__.__name__, referenced.uid) in exclude %}
+                            <li><em>{{fname}}</em> : {{fvalue}}</li>
+                        {% else %}
+                            <li><em>{{fname}}</em> : {{object_ul(referenced, max_depth - 1, exclude + [(leo.__class__.__name__, leo.uid())] )}}</li>
+                        {% endif %}
+                    {% else %}
+                        <li><em>{{fname}}</em> : <ul>
+                        {% for referenced in fdh.get_referenced(fvalue) %}
+                            {% if (referenced.__class__.__name__, referenced.uid) in exclude %}
+                                <li><em>{{fname}}</em> : {{fvalue}}</li>
+                            {% else %}
+                                <li><em>{{fname}}</em> : {{object_ul(referenced, max_depth - 1, exclude + [(leo.__class__.__name__, leo.uid())] )}}</li>
+                            {% endif %}
+                        {% endfor %}
+                        </ul></li>
+                    {% endif %}
+                {% else %}
+                    <li><em>{{fname}}</em> : {{fvalue}}</li>
+                {% endif %}
+            {% endfor %}
+        {% endif %}
+    </ul>
+{%- endmacro %}

lodel/settings/settings.py

 # settings.
 # Here is the conceptual presentation of Settings class initialization stages :
 #   -# Preloading (sets values like lodel2 library path or the plugins path)
-#   -# Ask a @ref lodel.settings.setting_loader.SettingsLoader to load all 
+#   -# Ask a @ref lodel.settings.settings_loader.SettingsLoader to load all
 #configurations files
 #   -# Fetch the list of plugins in the loaded settings
 #   -# Merge plugins settings specification with the global lodel settings 
     
     ## @brief Instanciate the Settings singleton
     # @param conf_dir str : The configuration directory
-    #@param custom_confspec None | dict : if given overwrite default lodel2
+    #@param custom_confspecs None | dict : if given overwrite default lodel2
     #confspecs
     def __init__(self, conf_dir, custom_confspecs = None):
         self.singleton_assert() # check that it is the only instance
 
     ##@brief An utility method that raises if the singleton is not in a good
     # state
+    #@param cls
     #@param expect_instanciated bool : if True we expect that the class is
     # allready instanciated, else not
     # @throw RuntimeError
                 raise RuntimeError("The Settings class is already started")
 
     ##@brief Saves a new configuration for section confname
+    #@param cls
     #@param confname is the name of the modified section
     #@param confvalue is a dict with variables to save
     #@param validator is a dict with adapted validator

lodel/settings/validator.py

             raise SettingsValidationError(e)
     
     ##@brief Register a new validator
+    # @param cls SettingValidator
     # @param name str : validator name
     # @param callback callable : the function that will validate a value
     # @param description str
         return copy.copy(cls._description)
 
     ##@brief Create and register a list validator
+    # @param cls SettingValidator
     # @param elt_validator callable : The validator that will be used for validate each elt value
     # @param validator_name str
     # @param description None | str
         return cls(validator_name)
  
     ##@brief Create and register a list validator which reads an array and returns a string
+    # @param cls SettingValidator
     # @param elt_validator callable : The validator that will be used for validate each elt value
     # @param validator_name str
     # @param description None | str
         return cls(validator_name)
     
     ##@brief Create and register a regular expression validator
+    # @param cls SettingValidator
     # @param pattern str : regex pattern
     # @param validator_name str : The validator name
     # @param description str : Validator description
 ##@brief Append a piece of confspec
 #@note orig is modified during the process
 #@param orig dict : the confspec to update
-#@param upd dict : the confspec to add
+#@param section str : the name of the section to add
+#@param key str : the name of the key to add
+#@param validator SettingValidator : The validator to use for this configuration key
+#@param default : the default value for this configuration key
 #@return new confspec
 def confspec_append(orig, section, key, validator, default):
     if section not in orig:

lodel/utils/mlstring.py

             self.values[lang] = val
 
     ##@brief Checks that given lang is valid
+    # @param cls MlString
     # @param lang str : the lang
     @classmethod
     def lang_is_valid(cls, lang):
         cls.__default_lang = lang
     
     ##@brief Return a mlstring loaded from a json string
+    # @param cls MlString
     # @param json_str str : Json string
     @classmethod
     def from_json(cls, json_str):

progs/slim/slim.py

 
 ##@brief Start an instance
 #@param names list : instance name list
+#@param foreground bool : defines if the starting instance will be executed as a subprocess in the background (if False) or as the main process (if True)
 def start_instances(names, foreground):
     pids = get_pids()
     store_datas = get_store_datas()

scripts/cbl.sh

 #
 # Scenario description :
 #
-# mass_creation instance_name iteration_count :
+# mass_creation instance_name iteration_count :
 #	Create iteration_count time a random leobject in given instance_name
 #	note : do note create relation between objects, only populate content
 #	
 # 	step 2 : loop on creation (using bash function curl_opt_create_CLSNAME)
 #		that return the POST fields (populated with random values)
 #
+# mass_get instance_name :
+#	Create all possible get for an instance
+#	step 1 : fetch all classes
+#	step 2 : for each class fetch all id
+#	step 3 : for all ids generate the gets
+#
 # mass_deletion instance_name iteration_count :
 #	Foreach non asbtracty class delete iteration_count time an object of
 #	current class in current instance
 	rm -v $cls_list_file >&2
 }
 
+mass_get() {
+	#mass get scenario
+	#$1 is instance name
+	cls_list_file=$(fetch_all_classes $1)
+	base_uri=$(_base_uri $1)
+
+	#Get the site root
+	echo "$base_uri/"
+	#Get the site class list
+	echo "$base_uri/list_classes"
+
+	for clsname in $(cat $cls_list_file)
+	do
+		#Get instances list for a class
+		echo "$base_uri/show_class?classname=$clsname"
+		ids_file=$(fetch_all_ids $1 $clsname)
+		for id in $(cat $ids_file)
+		do
+			#Get details on an instance
+			echo "$base_uri/show_object_detailled?classname=${clsname}&lodel_id=$id"
+			#Get base informations on an instance
+			echo "$base_uri/show_object?classname=${clsname}&lodel_id=$id"
+		done
+	done
+}
+
 mass_link_edit() {
 	#mass linking & edition scenarion
 	#$1 is instance name
 	done | shuf
 }
 
+get_queries_with_params "mass_get" $instance_list
 [ "$n_create" -gt 0 ] && get_queries_with_params "mass_creation" $instance_list $n_create
 [ "$n_edit" -gt 0 ] && get_queries_with_params "mass_link_edit" $instance_list $n_edit
 [ "$n_delete" -gt 0 ] && get_queries_with_params "mass_deletion" $instance_list $n_delete

tests/datahandlers/test_leobjectsubclassidentifier.py

+import unittest
+from unittest import mock 
+from unittest.mock import patch
+
+import leapi_dyncode as dyncode
+
+from lodel.leapi.datahandlers.datas import LeobjectSubclassIdentifier
+from lodel.plugins.dummy_datasource.datasource import DummyDatasource
+
+
+class LeobjectSubclassIdentifierTestCase(unittest.TestCase):
+    
+    def test_throws_error_if_not_internal(self):
+        self.failUnlessRaises(RuntimeError, LeobjectSubclassIdentifier, internal=False)
+        

tests/datahandlers/test_uniqid.py

+import unittest
+from unittest import mock 
+from unittest.mock import patch
+
+import leapi_dyncode as dyncode
+
+from lodel.leapi.datahandlers.datas import UniqID
+from lodel.plugins.dummy_datasource.datasource import DummyDatasource
+
+
+class UniqIDTestCase(unittest.TestCase):
+    
+    def test_construct_data_sets_new_uid_if_none(self):
+        sent_uid = None
+        mocked_returned_uid = 987654321
+        
+        with patch.object(DummyDatasource, 'new_numeric_id', return_value=mocked_returned_uid) as mock_method:
+            returned_uid = UniqID.construct_data(UniqID, dyncode.Object, 'lodel_id', '', sent_uid)
+            
+            mock_method.assert_called_once_with(dyncode.Object)
+            self.assertEqual(returned_uid, mocked_returned_uid)
+            
+    def test_construct_data_returns_already_set_uid(self):
+        sent_uid = 123456789
+        mocked_returned_uid = 987654321
+        
+        with patch.object(DummyDatasource, 'new_numeric_id', return_value=mocked_returned_uid) as mock_method:
+            returned_uid = UniqID.construct_data(UniqID, dyncode.Object, '', '', sent_uid)
+
+            self.assertEqual(returned_uid, sent_uid)
+            mock_method.assert_not_called()     
+