Пример #1
0
    def test_project_with_multiple_config_templates(self):
        # create test data
        p1 = Project(name="Project with config templates")

        ct1 = ConfigTemplate(name="first", project=p1)
        ct2 = ConfigTemplate(name="second", project=p1)

        ct1.project = p1
        ct2.project = p1

        db.session.add(p1)
        db.session.add(ct1)
        db.session.add(ct2)
        db.session.commit()

        # read the project from the database
        received_p1 = Project.query.filter_by(
            name="Project with config templates").first()

        received_ct1 = received_p1.configtemplates.all()[0]
        received_ct2 = received_p1.configtemplates.all()[1]

        self.assertEqual(p1, received_p1)
        self.assertEqual(ct1, received_ct1)
        self.assertEqual(ct2, received_ct2)
Пример #2
0
    def test_config_template_update_variable(self):
        p1 = Project(name="Project 1")
        ct1 = ConfigTemplate(name="first script", project=p1)
        ct2 = ConfigTemplate(name="second script", project=p1)
        ct1.project = p1
        ct2.project = p1
        db.session.add(p1)
        db.session.add(ct1)
        db.session.add(ct2)
        db.session.commit()

        # verify that the variables are not defined
        self.assertFalse(ct1.is_variable_defined("first variable"))
        self.assertFalse(ct1.is_variable_defined("second variable"))
        self.assertFalse(ct2.is_variable_defined("first variable"))

        # add variables to the first configuration template
        ct1var1_desc = "description for first P1 variable"
        ct1.update_template_variable("first variable", ct1var1_desc)
        ct1.update_template_variable("second variable",
                                     "description for second P1 variable")
        ct2.update_template_variable("first variable",
                                     "description for first P2 variable")

        self.assertTrue(len(ct1.variables.all()) == 2 + 1)
        self.assertTrue(len(ct2.variables.all()) == 1 + 1)

        # update value
        ct1var1_desc_mod = "modified description"
        ct1.update_template_variable("first variable", ct1var1_desc_mod)

        ct1var1 = ct1.get_template_variable_by_name("first_variable")
        self.assertNotEqual(ct1var1.description, ct1var1_desc)
        self.assertEqual(ct1var1.description, ct1var1_desc_mod)
Пример #3
0
    def test_config_template_add_variables_and_lookup(self):
        # create test data
        p1 = Project(name="Project 1")
        ct1 = ConfigTemplate(name="first script", project=p1)
        ct2 = ConfigTemplate(name="second script", project=p1)
        ct1.project = p1
        ct2.project = p1
        db.session.add(p1)
        db.session.add(ct1)
        db.session.add(ct2)
        db.session.commit()

        # verify that the variables are not defined
        self.assertFalse(ct1.is_variable_defined("first variable"))
        self.assertFalse(ct1.is_variable_defined("second variable"))
        self.assertFalse(ct2.is_variable_defined("first variable"))

        # add variables to the first configuration template
        ct1var1_desc = "description for first P1 variable"
        ct1var2_desc = "description for second P1 variable"
        ct1.update_template_variable("first variable", ct1var1_desc)
        ct1.update_template_variable("second variable", ct1var2_desc)
        self.assertFalse(ct2.is_variable_defined("first variable"))
        db.session.commit()

        # add variables to the second configuration template
        ct2var1_desc = "description for first P2 variable"
        ct2.update_template_variable("first variable", ct2var1_desc)
        db.session.commit()

        # retrieve variables (hostname is automatically created)
        self.assertTrue(len(ct1.variables.all()) == 2 + 1)
        self.assertTrue(len(ct2.variables.all()) == 1 + 1)
        self.assertTrue(ct1.is_variable_defined("first_variable"))
        self.assertTrue(ct1.is_variable_defined("second_variable"))
        self.assertTrue(ct2.is_variable_defined("first_variable"))

        ct1var1 = ct1.get_template_variable_by_name("first_variable")
        self.assertTrue(type(ct1var1) is TemplateVariable)
        self.assertEqual(ct1var1.config_template, ct1)
        self.assertEqual(ct1var1.description, ct1var1_desc)

        ct1var2 = ct1.get_template_variable_by_name("second_variable")
        self.assertTrue(type(ct1var2) is TemplateVariable)
        self.assertEqual(ct1var2.config_template, ct1)
        self.assertEqual(ct1var2.description, ct1var2_desc)

        ct2var1 = ct2.get_template_variable_by_name("first_variable")
        self.assertTrue(type(ct2var1) is TemplateVariable)
        self.assertEqual(ct2var1.config_template, ct2)
        self.assertEqual(ct2var1.description, ct2var1_desc)

        # invalid template lookup
        with self.assertRaises(TemplateVariableNotFoundException):
            ct1.get_template_variable_by_name("unknown key")
Пример #4
0
    def test_config_template_delete_cascade_option(self):
        p1 = Project(name="Project 1")
        ct1 = ConfigTemplate(name="first script", project=p1)
        ct2 = ConfigTemplate(name="second script", project=p1)
        ct1.project = p1
        ct2.project = p1
        ct1.update_template_variable("test 1")
        ct1.update_template_variable("test 2")
        ct1.update_template_variable("test 3")
        ct2.update_template_variable("other test 1")
        ct2.update_template_variable("other test 2")
        ct2.update_template_variable("other test 3")

        tvs1 = TemplateValueSet("valueset 1", ct1)
        tvs2 = TemplateValueSet("valueset 2", ct1)
        tvs3 = TemplateValueSet("valueset 1", ct2)
        tvs4 = TemplateValueSet("valueset 2", ct2)
        tvs5 = TemplateValueSet("valueset 3", ct2)

        db.session.add_all([p1, ct1, ct2, tvs1, tvs2, tvs3, tvs4, tvs5])
        db.session.commit()

        # test cascade option when deleting objects (hostname is automatically created)
        self.assertTrue(
            len(TemplateVariable.query.all()) == 6 + 2,
            len(TemplateVariable.query.all()))
        self.assertTrue(
            len(TemplateValueSet.query.all()) == 5,
            len(TemplateValueSet.query.all()))
        db.session.delete(ct1)
        self.assertTrue(len(Project.query.all()) == 1)
        self.assertTrue(
            len(TemplateVariable.query.all()) == 3 + 1,
            len(TemplateVariable.query.all()))
        self.assertTrue(
            len(TemplateValueSet.query.all()) == 3,
            len(TemplateValueSet.query.all()))
        db.session.delete(ct2)
        self.assertTrue(len(Project.query.all()) == 1)
        self.assertTrue(
            len(TemplateVariable.query.all()) == 0,
            len(TemplateVariable.query.all()))
        self.assertTrue(
            len(TemplateValueSet.query.all()) == 0,
            len(TemplateValueSet.query.all()))
Пример #5
0
def add_config_template(project_id):
    """add a new Config Template

    :param project_id:
    :return:
    """
    if not session.get('logged_in'):
        return render_template("login.html")
    else:

        parent_project = Project.query.filter(
            Project.id == project_id).first_or_404()

        form = ConfigTemplateForm(request.form)

        if form.validate_on_submit():
            try:
                config_template = ConfigTemplate(name="",
                                                 project=parent_project)

                config_template.name = form.name.data
                config_template.template_content = form.template_content.data
                config_template.project = parent_project

                db.session.add(config_template)
                db.session.commit()

                flash(
                    "Config template <strong>%s</strong> successful created" %
                    config_template.name, "success")

                return redirect(
                    url_for("view_config_template",
                            project_id=project_id,
                            config_template_id=config_template.id))

            except IntegrityError as ex:
                if "UNIQUE constraint failed" in str(ex):
                    msg = "Config Template name already in use, please use another one"

                else:
                    msg = "Config template was not created (unknown error, see log for details)"

                logger.error(msg, exc_info=True)
                flash(msg, "error")
                db.session.rollback()

            except Exception:
                msg = "Config template was not created (unknown error, see log for details)"
                logger.error(msg, exc_info=True)
                flash(msg, "error")

        return render_template("config_template/add_config_template.html",
                               project_id=project_id,
                               project=parent_project,
                               form=form)
Пример #6
0
    def test_config_template_name_validation_function(self):
        p1 = Project(name="Project 1")
        p2 = Project(name="Project 2")
        p1ct1 = ConfigTemplate(name="first", project=p1)
        p2ct2 = ConfigTemplate(name="first", project=p2)
        p1ct3 = ConfigTemplate(name="second", project=p1)
        p1ct1.project = p1
        p2ct2.project = p2
        p1ct3.project = p1

        db.session.add(p1)
        db.session.add(p1ct1)
        db.session.commit()

        # test validation of the config template name strings
        self.assertFalse(p1.valid_config_template_name("first"))
        self.assertFalse(p1.valid_config_template_name("second"))

        self.assertTrue(p1.valid_config_template_name("first1"))
        self.assertTrue(p2.valid_config_template_name("second"))
Пример #7
0
    def test_config_template_name_constraint(self):
        # create test data
        p1_name = "Project with config templates"
        p2_name = "Another Project with config templates"
        p2ct1_template_content = "Code for the second project"
        p1 = Project(name=p1_name)
        p2 = Project(name=p2_name)

        p1ct1 = ConfigTemplate(name="first", project=p1)
        p1ct2 = ConfigTemplate(name="second", project=p1)
        p2ct1 = ConfigTemplate(name="first",
                               template_content=p2ct1_template_content,
                               project=p2)

        p1ct1.project = p1
        p1ct2.project = p1
        p2ct1.project = p2

        db.session.add_all([p1, p2, p1ct1, p1ct2, p2ct1])
        db.session.commit()

        # get project 1 data and verify results
        received_p1 = Project.query.filter_by(name=p1_name).first()
        self.assertEqual(received_p1, p1)

        # verify results
        query_result = received_p1.configtemplates.all()
        self.assertTrue(len(query_result) == 2)

        # get configuration templates for project 1
        query_result = received_p1.configtemplates.filter_by(
            name="first").all()
        self.assertTrue(len(query_result) == 1, "Too many results received")

        received_p1ct1 = query_result[0]
        self.assertEqual(received_p1ct1, p1ct1)
        self.assertNotEqual(received_p1ct1.template_content,
                            p2ct1_template_content)

        # get project 2 data and verify results
        received_p2 = Project.query.filter_by(name=p2_name).first()
        self.assertEqual(received_p2, p2)

        # verify results
        query_result = received_p2.configtemplates.all()
        self.assertTrue(len(query_result) == 1)

        # get configuration templates for project 2
        query_result = received_p2.configtemplates.filter_by(
            name="first").all()
        self.assertTrue(len(query_result) == 1, "Too many results received")

        received_p2ct1 = query_result[0]
        self.assertEqual(received_p2ct1, p2ct1)
        self.assertEqual(received_p2ct1.template_content,
                         p2ct1_template_content)

        # try to create another "second" config template
        with self.assertRaises(IntegrityError):
            faulty_ct3 = ConfigTemplate(name="second",
                                        template_content="doesn't matter",
                                        project=p1)