From cff4241ecf4f8dc74a8c2623ced039eb131aebdf Mon Sep 17 00:00:00 2001 From: Quentin Mondot Date: Thu, 21 Aug 2025 16:01:23 +0200 Subject: [PATCH] [IMP] survey_record_generation : add tests on record creation --- .../models/survey_question_answer.py | 10 +- .../survey_record_creation_field_values.py | 36 +- .../models/survey_user_input.py | 10 +- survey_record_generation/tests/__init__.py | 1 + .../tests/test_survey_record_creation.py | 813 ++++++++++++++++++ 5 files changed, 842 insertions(+), 28 deletions(-) create mode 100644 survey_record_generation/tests/__init__.py create mode 100644 survey_record_generation/tests/test_survey_record_creation.py diff --git a/survey_record_generation/models/survey_question_answer.py b/survey_record_generation/models/survey_question_answer.py index 87b1144..fc2a59a 100644 --- a/survey_record_generation/models/survey_question_answer.py +++ b/survey_record_generation/models/survey_question_answer.py @@ -9,15 +9,15 @@ _logger = logging.getLogger(__name__) class SurveyQuestionAnswer(models.Model): _inherit = 'survey.question.answer' - record_id = fields.Reference(string="Referenced record", selection='_selection_target_model') - model_id = fields.Many2one('ir.model', related="question_id.model_id") + record_id = fields.Reference(string="Referenced record", selection='_selection_target_model') + model_id = fields.Many2one('ir.model', related="question_id.model_id") answer_values_type = fields.Selection(related="question_id.answer_values_type") value_char = fields.Char('Value') @api.model def _selection_target_model(self): return [(model.model, model.name) for model in self.env['ir.model'].sudo().search([])] - + @api.onchange('record_id') def onchange_record_id(self): if self.record_id: @@ -31,7 +31,7 @@ class SurveyQuestionAnswer(models.Model): or "record_id" not in fields ): return result - + model = self.env['ir.model'].browse(result.get("model_id")).model res = self.env[model].search([], limit=1) if res: @@ -39,4 +39,4 @@ class SurveyQuestionAnswer(models.Model): model, res.id, ) - return result \ No newline at end of file + return result diff --git a/survey_record_generation/models/survey_record_creation_field_values.py b/survey_record_generation/models/survey_record_creation_field_values.py index a7bc320..744ef00 100644 --- a/survey_record_generation/models/survey_record_creation_field_values.py +++ b/survey_record_generation/models/survey_record_creation_field_values.py @@ -8,7 +8,7 @@ from odoo.tools.misc import format_date _logger = logging.getLogger(__name__) -type_mapping = { +type_mapping = { #field types on the left, question types on the right. TODO : what about booleans ? "char": ["char_box", "numerical_box", "date", "datetime", "simple_choice", "multiple_choice"], "text": ["char_box", "date", "simple_choice"], "html": ["text_box", "numerical_box", "datetime", "simple_choice"], @@ -17,7 +17,7 @@ type_mapping = { "date": ["date"], "datetime": ["datetime"], "many2one": ["simple_choice"], - "many2many": ["multiple_choice"], + "many2many": ["multiple_choice"], "selection": ["char_box", "simple_choice"] } @@ -32,7 +32,7 @@ class SurveyRecordCreationFieldValues(models.Model): model_id = fields.Many2one('ir.model', related="survey_record_creation_id.model_id") field_id = fields.Many2one( - 'ir.model.fields', + 'ir.model.fields', domain="[('model_id','=',model_id),('readonly','=',False),('ttype','in',['char','selection','text','html','integer','float','date','datetime','many2one','many2many', 'boolean'])]", ondelete="cascade") field_relation = fields.Char(related='field_id.relation') @@ -40,10 +40,10 @@ class SurveyRecordCreationFieldValues(models.Model): field_help = fields.Html('Help', compute="_compute_field_help") value_origin = fields.Selection( - [('fixed','Fixed'),('question','Question'),('other_record','From other created record')], - string="Value origin", - required=True, - default='fixed', + [('fixed','Fixed'),('question','Question'),('other_record','From other created record')], + string="Value origin", + required=True, + default='fixed', help="""* Fixed: you can set the value in value field * Question: Response of the question will set the value. If you do not see your question, maybe the type of question do not match the type of field * From other created record: You can set other record creation to link several created records. Can only be used with many2one fields.""") @@ -57,7 +57,7 @@ class SurveyRecordCreationFieldValues(models.Model): fixed_value_integer = fields.Integer("Value") fixed_value_float = fields.Float("Value") fixed_value_date = fields.Date("Value") - fixed_value_datetime = fields.Datetime("Value") + fixed_value_datetime = fields.Datetime("Value") fixed_value_boolean = fields.Boolean("Value") displayed_value = fields.Char("Value", compute="_compute_displayed_value") @@ -84,7 +84,7 @@ class SurveyRecordCreationFieldValues(models.Model): record_creation_field_values.allowed_question_ids = None return question_domain = [('survey_id','=',record_creation_field_values.survey_id.id)] - + if record_creation_field_values.field_id.ttype in ['many2one','many2many']: question_domain.extend(['|','&',('answer_values_type','=','record'),('model_id','=',record_creation_field_values.field_id.relation),('answer_values_type','=','value')]) if record_creation_field_values.field_id.ttype in type_mapping: @@ -96,7 +96,7 @@ class SurveyRecordCreationFieldValues(models.Model): @api.model def _selection_target_model(self): return [(model.model, model.name) for model in self.env['ir.model'].sudo().search([])] - + def clean_values(self): # clean values self.fixed_value_many2many = None @@ -119,7 +119,7 @@ class SurveyRecordCreationFieldValues(models.Model): # Set reference field model and select first record if self.field_id and self.field_id.ttype == 'many2one' and self.field_id.relation: rec = self.env[self.field_id.relation].search([], limit=1) - if rec: + if rec: self.fixed_value_many2one = f"{self.field_id.relation},{rec.id}" else: model_name = self.env['ir.model'].search([('model','=',self.field_id.relation)]).name @@ -136,12 +136,12 @@ class SurveyRecordCreationFieldValues(models.Model): if self.value_origin == 'fixed': if self.field_type == 'many2one': if self.fixed_value_many2one: - return self.fixed_value_many2one.id + return self.fixed_value_many2one.id elif self.field_type == 'many2many': return [m2m.value_reference.id for m2m in self.fixed_value_many2many if m2m.value_reference] else: return self["fixed_value_"+self.field_type] - + @api.onchange("fixed_value_char","fixed_value_selection","fixed_value_text","fixed_value_html","fixed_value_integer","fixed_value_float","fixed_value_date","fixed_value_datetime",'fixed_value_many2one', "fixed_value_many2many","other_created_record_id","question_id") def _compute_displayed_value(self): @@ -172,7 +172,7 @@ class SurveyRecordCreationFieldValues(models.Model): record.displayed_value = "" class SurveyRecordCreationFieldValuesX2m(models.Model): - """O2m an M2m default values + """O2m an M2m default values """ _name = 'survey.record.creation.field.values.x2m' @@ -182,16 +182,16 @@ class SurveyRecordCreationFieldValuesX2m(models.Model): @api.model def _selection_target_model(self): return [(model.model, model.name) for model in self.env['ir.model'].sudo().search([])] - + @api.onchange('survey_record_creation_field_values_id') def _onchange_model_name(self): # Set reference field model and select first record - field = self.survey_record_creation_field_values_id.field_id + field = self.survey_record_creation_field_values_id.field_id if field and "2many" in field.ttype and field.relation: rec = self.env[field.relation].search([], limit=1) - if rec: + if rec: self.value_reference = f"{field.relation},{rec.id}" else: model_name = self.env['ir.model'].search([('model','=',field.relation)]).name - raise ValueError(_('You should append at least one record in %s',(model_name,))) \ No newline at end of file + raise ValueError(_('You should append at least one record in %s',(model_name,))) diff --git a/survey_record_generation/models/survey_user_input.py b/survey_record_generation/models/survey_user_input.py index c34dac2..bf376f2 100644 --- a/survey_record_generation/models/survey_user_input.py +++ b/survey_record_generation/models/survey_user_input.py @@ -41,7 +41,7 @@ class SurveyUserInput(models.Model): model = record_creation.model_id.model vals = {} ModelClass = self.env[model] - + for field_value in record_creation.field_values_ids: if field_value.value_origin == 'fixed': vals[field_value.field_id.name] = field_value.get_fixed_value_for_record_creation() @@ -55,7 +55,7 @@ class SurveyUserInput(models.Model): if field_value.question_id.question_type in ['simple_choice', 'multiple_choice','matrix']: if field_value.question_id.answer_values_type == 'record': record_ids = [] - for user_input_line in user_input_lines: + for user_input_line in user_input_lines: if user_input_line.suggested_answer_id and user_input_line.suggested_answer_id.record_id: record_ids.append(user_input_line.suggested_answer_id.record_id.id) if field_value.question_id.question_type == 'simple_choice': @@ -67,7 +67,7 @@ class SurveyUserInput(models.Model): vals[field_value.field_id.name] = record_ids if field_value.question_id.answer_values_type == 'value': if field_value.field_id.ttype == "boolean": - boolean_value = user_input_lines[0].suggested_answer_id.value_char in [True, 1, "1", "True", "true", "Oui", "oui"] + boolean_value = user_input_lines[0].suggested_answer_id.value_char in [True, 1, "1", "True", "true", "Oui", "oui", "Yes", "yes"] vals[field_value.field_id.name] = boolean_value else: vals[field_value.field_id.name] = user_input_lines[0].suggested_answer_id.value_char @@ -110,8 +110,8 @@ class SurveyUserInput(models.Model): # Link generated records to user input self.env['survey.generated.record'].create({ 'survey_record_creation_name':record_creation.name, - 'survey_record_creation_id':record_creation.id, - 'user_input_id':user_input.id, + 'survey_record_creation_id':record_creation.id, + 'user_input_id':user_input.id, "created_record_id":"%s,%s" % (model,record.id) }) diff --git a/survey_record_generation/tests/__init__.py b/survey_record_generation/tests/__init__.py new file mode 100644 index 0000000..5b794a3 --- /dev/null +++ b/survey_record_generation/tests/__init__.py @@ -0,0 +1 @@ +from . import test_survey_record_creation diff --git a/survey_record_generation/tests/test_survey_record_creation.py b/survey_record_generation/tests/test_survey_record_creation.py new file mode 100644 index 0000000..89af8b1 --- /dev/null +++ b/survey_record_generation/tests/test_survey_record_creation.py @@ -0,0 +1,813 @@ +from datetime import date + +from odoo.addons.survey.tests.common import SurveyCase + +from psycopg2 import IntegrityError + + +class TestSurveyRecordCreation(SurveyCase): + def setUp(self): + super().setUp() + self.survey = self.env["survey.survey"].create( + { + "title": "Test Survey", + } + ) + + def test_record_is_created(self): + # Easy test to become familiar with the subject + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + + def test_all_types_of_question(self): + # Still todo : "datetime" and "text_box" + # Also todo : "simple_choice" with answer_values_type "no" + # Also todo : "multiple_choice" with answer_values_type "no" and "value" + # Note : matrix question type is never proposed in the allowed_question_ids + + self.res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + + ### "char_box" type of question, tested with field CHAR "name" ### + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + + ### "numerical_box" type of question, tested with FLOAT field "partner_latitude" ### + self.question_partner_latitude = self._add_question( + page=None, + name="Partner latitude", + qtype="numerical_box", + survey_id=self.survey.id, + sequence=1, + ) + + self._add_answer_line( + question=self.question_partner_latitude, + answer=self.answer, + answer_value=44.73333, + ) + + partner_latitude_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "partner_latitude")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": partner_latitude_field.id, + "value_origin": "question", + "question_id": self.question_partner_latitude.id, + } + ) + + ### "date" type of question, tested with DATE field "date" ### + self.question_date = self._add_question( + page=None, name="Date", qtype="date", survey_id=self.survey.id, sequence=1 + ) + + self._add_answer_line( + question=self.question_date, answer=self.answer, answer_value=date.today() + ) + + date_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "date")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": date_field.id, + "value_origin": "question", + "question_id": self.question_date.id, + } + ) + + ### "simple_choice" type of question, tested with SELECTION field "type" ### + ### Here we also test answer_values_type "value" + self.question_type = self._add_question( + page=None, + name="Type", + qtype="simple_choice", + labels=[ + {"value": "contact"}, + {"value": "other"}, + ], + survey_id=self.survey.id, + sequence=1, + answer_values_type="value" + ) + + self.question_type.suggested_answer_ids[0].value_char = self.question_type.suggested_answer_ids[0].value + self.question_type.suggested_answer_ids[1].value_char = self.question_type.suggested_answer_ids[1].value + + self._add_answer_line( + question=self.question_type, answer=self.answer, + answer_value=self.question_type.suggested_answer_ids[0].id + ) + + type_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "type")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": type_field.id, + "value_origin": "question", + "question_id": self.question_type.id, + } + ) + + ### "simple_choice" type of question, tested with MANY2ONE field "title" ### + ### Here we also test answer_values_type "record" + + mister_title = self.env["res.partner.title"].create({"name": "Mister"}) + madam_title = self.env["res.partner.title"].create({"name": "Madam"}) + self.question_title = self._add_question( + page=None, + name="Title", + qtype="simple_choice", + labels=[ + {"value": mister_title.display_name}, + {"value": madam_title.display_name}, + ], + survey_id=self.survey.id, + sequence=1, + answer_values_type="record" + ) + + self.question_title.suggested_answer_ids[0].record_id = f"res.partner.title,{mister_title.id}" + self.question_title.suggested_answer_ids[1].record_id = f"res.partner.title,{madam_title.id}" + + title_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "title")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": title_field.id, + "value_origin": "question", + "question_id": self.question_title.id, + } + ) + + self._add_answer_line( + question=self.question_title, answer=self.answer, + answer_value=self.question_title.suggested_answer_ids[0].id + ) + + ### "multiple_choice" type of question, tested with MANY2MANY field "category" ### + adult_category = self.env["res.partner.category"].create({"name": "Adult"}) + teenager_category = self.env["res.partner.category"].create({"name": "Teenager"}) + child_category = self.env["res.partner.category"].create({"name": "Child"}) + self.question_category = self._add_question( + page=None, + name="Category", + qtype="multiple_choice", + labels=[ + {"value": adult_category.display_name}, + {"value": teenager_category.display_name}, + {"value": child_category.display_name}, + ], + survey_id=self.survey.id, + sequence=1, + answer_values_type="record" + ) + + self.question_category.suggested_answer_ids[0].record_id = f"res.partner.category,{adult_category.id}" + self.question_category.suggested_answer_ids[1].record_id = f"res.partner.category,{teenager_category.id}" + self.question_category.suggested_answer_ids[2].record_id = f"res.partner.category,{child_category.id}" + + category_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "category_id")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": self.res_partner_model.id, + "field_id": category_field.id, + "value_origin": "question", + "question_id": self.question_category.id, + } + ) + + self._add_answer_line( + question=self.question_category, answer=self.answer, + answer_value=self.question_category.suggested_answer_ids[0].id + ) + self._add_answer_line( + question=self.question_category, answer=self.answer, + answer_value=self.question_category.suggested_answer_ids[1].id + ) + + self.answer._mark_done() + partner = self.env["res.partner"].search( + [ + ("name", "=", "Jean"), + ("partner_latitude", "=", 44.73333), + ("date", "=", date.today()), + ("type", "=", "contact"), + ("title", "=", mister_title.id), + ("category_id", "=", adult_category.id), + ("category_id", "=", teenager_category.id), + ("category_id", "!=", child_category.id), + ] + ) + self.assertTrue(partner.name == "Jean") + + def test_records_are_created(self): + # we test that several records can be created at the end of the same survey + # concurrently, we test the value_origin "other_record" and "fixed" + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.contact_survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.contact_survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + + res_partner_bank_model = self.env["ir.model"]._get("res.partner.bank") + self.bank_survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Bank", + "survey_id": self.survey.id, + "model_id": res_partner_bank_model.id, + } + ) + # Below we test "value_origin": "other_record" + partner_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner.bank"), ("name", "=", "partner_id")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.bank_survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_bank_model.id, + "field_id": partner_field.id, + "value_origin": "other_record", + "other_created_record_id": self.contact_survey_record_creation.id, + } + ) + # Below we test "value_origin": "fixed" + acc_number_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner.bank"), ("name", "=", "acc_number")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.bank_survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_bank_model.id, + "field_id": acc_number_field.id, + "value_origin": "fixed", + "fixed_value_char": "FR76 1444 5004 0004 0000 0000 000", + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + bank_account = self.env["res.partner.bank"].search( + [("partner_id", "=", partner.id)] + ) + self.assertTrue(bank_account.acc_number == "FR76 1444 5004 0004 0000 0000 000") + + def test_records_of_same_model_are_created(self): + # We test that 2 contacts are created + self.first_question_name = self._add_question( + page=None, + name="Name of first person", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + self.second_question_name = self._add_question( + page=None, + name="Name of second person", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.first_contact_survey_record_creation = self.env[ + "survey.record.creation" + ].create( + { + "name": "First contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.first_contact_survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.first_question_name.id, + } + ) + self.second_contact_survey_record_creation = self.env[ + "survey.record.creation" + ].create( + { + "name": "Second contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.second_contact_survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.second_question_name.id, + } + ) + + self.first_answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.first_question_name, + answer=self.first_answer, + answer_value="Jean", + ) + self._add_answer_line( + question=self.second_question_name, + answer=self.first_answer, + answer_value="Jeanne", + ) + self.first_answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + partner = self.env["res.partner"].search([("name", "=", "Jeanne")]) + self.assertTrue(partner.name == "Jeanne") + + def test_required_fields_are_not_filled_up(self): + # In this test, we check the behavior when a required field is missing + self.question_email = self._add_question( + page=None, + name="Email", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + email_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "email")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": email_field.id, + "value_origin": "question", + "question_id": self.question_email.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_email, answer=self.answer, answer_value="jean@test.fr" + ) + + with self.assertRaises(IntegrityError): + # TODO : propose a better user experience than IntegrityError when a mandatory field is missing + self.answer._mark_done() + + def test_survey_submitted_twice_by_same_user(self): + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partners = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(len(partners) == 2) + + def test_unicity_check(self): + # In this test, we check that the behavior of unicity_check works + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "unicity_check": True, + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self.answer._mark_done() + + partners = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + self.assertFalse(len(partners) == 2) + + def test_some_questions_are_not_answered(self): + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + self.question_email = self._add_question( + page=None, + name="Email", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + mister_title = self.env["res.partner.title"].create({"name": "Mister"}) + madam_title = self.env["res.partner.title"].create({"name": "Madam"}) + self.question_title = self._add_question( + page=None, + name="Title", + qtype="simple_choice", + labels=[ + {"value": mister_title.display_name}, + {"value": madam_title.display_name}, + ], + survey_id=self.survey.id, + sequence=1, + answer_values_type="record" + ) + self.question_title.suggested_answer_ids[0].record_id = f"res.partner.title,{mister_title.id}" + self.question_title.suggested_answer_ids[1].record_id = f"res.partner.title,{madam_title.id}" + + self.question_street = self._add_question( + page=None, + name="Street", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + email_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "email")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": email_field.id, + "value_origin": "question", + "question_id": self.question_email.id, + } + ) + title_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "title")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": title_field.id, + "value_origin": "question", + "question_id": self.question_title.id, + } + ) + street_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "street")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": street_field.id, + "value_origin": "question", + "question_id": self.question_street.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, answer_value="Jean" + ) + self._add_answer_line( + question=self.question_email, answer=self.answer, answer_value=False, skipped=True, answer_type=False + ) + self._add_answer_line( + question=self.question_title, answer=self.answer, answer_value=False, skipped=True, answer_type=False + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.name == "Jean") + self.assertFalse(partner.email) + self.assertFalse(partner.title) + self.assertFalse(partner.street) + + def test_boolean_field(self): + self.question_name = self._add_question( + page=None, + name="Name", + qtype="char_box", + survey_id=self.survey.id, + sequence=1, + ) + self.question_employee = self._add_question( + page=None, + name="Employee", + qtype="simple_choice", + labels=[ + {"value": "yes"}, + {"value": "no"}, + ], + survey_id=self.survey.id, + sequence=1, + answer_values_type="value" + ) + + self.question_employee.suggested_answer_ids[0].value_char = self.question_employee.suggested_answer_ids[0].value + self.question_employee.suggested_answer_ids[1].value_char = self.question_employee.suggested_answer_ids[1].value + + res_partner_model = self.env["ir.model"]._get("res.partner") + self.survey_record_creation = self.env["survey.record.creation"].create( + { + "name": "Contact", + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + } + ) + + name_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "name")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": name_field.id, + "value_origin": "question", + "question_id": self.question_name.id, + } + ) + employee_field = self.env["ir.model.fields"].search( + [("model", "=", "res.partner"), ("name", "=", "employee")] + ) + self.env["survey.record.creation.field.values"].create( + { + "survey_record_creation_id": self.survey_record_creation.id, + "survey_id": self.survey.id, + "model_id": res_partner_model.id, + "field_id": employee_field.id, + "value_origin": "question", + "question_id": self.question_employee.id, + } + ) + + self.answer = self._add_answer( + survey=self.survey, partner=False, email="jean@test.fr" + ) + self._add_answer_line( + question=self.question_name, answer=self.answer, + answer_value="Jean" + ) + self._add_answer_line( + question=self.question_employee, answer=self.answer, + answer_value=self.question_employee.suggested_answer_ids[0].id + ) + self.answer._mark_done() + + partner = self.env["res.partner"].search([("name", "=", "Jean")]) + self.assertTrue(partner.employee) + + + # def test_origin_other_record_wrong_order(self): + # # In this test, we check that an error is raised when the record is created after the one using it + # ... + #