Beispiel #1
0
 def count(self):
     """
     Return the number of test cases to be created.
     """
     if self._count is None:
         text = self.fetch_text(self._root, "Count")
         try:
             self._count = int(text)
         except Exception:
             message = "Text in Count element is not a number - '" + text + "'"
             raise SuiteDreamsException(message)
         if self._count < 0:
             message = "Count must not be a negative number - " + text
             raise SuiteDreamsException(message)
     return self._count
Beispiel #2
0
    def title(self, content):
        """
        Set the value of the title.

        Argument:
            content - the title of the test page
        """
        if content is None:
            message = "Title of test case must not be None"
            raise SuiteDreamsException(message)
        if len(content) == 0:
            message = "Title of test case must not be empty"
            raise SuiteDreamsException(message)
        self._title = content
        return
Beispiel #3
0
 def parse(self):
     """
     Parse the product spec file
     """
     if not ProductSpec.file_exists(self.spec_file_name):
         raise SuiteDreamsException("Product spec file does not exist - " + self.spec_file_name)
     try:
         tree = Et.parse(self.spec_file_name)
         root = tree.getroot()
         tag = root.tag
         if tag != "TestSuite":
             raise SuiteDreamsException("Root element is not TestSuite - " + tag)
         self._root = root
     except Exception as e:
         raise SuiteDreamsException(str(e))
     return
Beispiel #4
0
 def seed(self):
     """Return the seed for the random number generator"""
     if self._seed is None:
         value = self.fetch_text(self._root, "Seed")
         try:
             self._seed = int(value)
         except ValueError:
             message = "Value for seed is not a valid integer - " + value
             raise SuiteDreamsException(message)
     return self._seed
Beispiel #5
0
 def is_coverable_created(coverage_element):
     """Return true if the coverage is to be created"""
     select = coverage_element.get("selection")
     if select is None:
         result = False
     elif select == "create":
         result = True
     elif select == "select":
         result = False
     else:
         message = "Invalid value for select attribute on <Coverable> element - " + select
         raise SuiteDreamsException(message)
     return result
Beispiel #6
0
    def fetch_weight(element):
        """
        Return the value of the weight attribute as an integer.  This is an integer between 0
        and 100 inclusive.

        Argument:
            element - an XML element that may or may not have a weight attribute
        """
        assert element is not None, "fetch_weight: element must not be None"
        value = element.get("weight", default="100")
        try:
            weight = int(value)
        except ValueError:
            message = "Illegal value for weight attribute in element "
            message += element.tag
            message += " - " + value
            raise SuiteDreamsException(message)
        if weight < 0 or weight > 100:
            message = "Weight on element "
            message += element.tag
            message += " must be between 0 and 100 inclusive, not - " + value
            raise SuiteDreamsException(message)
        return weight
Beispiel #7
0
    def process_coverage_term(self, coverage_term_element):
        """
        Process the coverage term element.

        Argument:
            coverage_term_element - a <CoverageTerm> element
        """
        coverage_term_code = self.product_spec.fetch_text(coverage_term_element, "CoverageTermCode")
        term_elements = self.product_spec.fetch_all_elements(coverage_term_element, "Term")
        if len(term_elements) == 0:
            message = "Coverage term must have terms - " + coverage_term_code
            raise SuiteDreamsException(message)
        value = self.process_values(coverage_term_element, coverage_term_code, "Term")
        self.add_with(coverage_term_code, value)
        return
Beispiel #8
0
    def process_question_set(self, question_set_element):
        """
        Output the questions from a questions set.  A question set is a grouping of questions.

        Argument:
            question_set_element - a <QuestionSet> element
        """
        question_set_code = self.product_spec.fetch_text(question_set_element, "QuestionSetCode")
        question_elements = self.product_spec.fetch_all_elements(question_set_element, "Question")
        if len(question_elements) == 0:
            message = "Question set does not have any questions - " + question_set_code
            raise SuiteDreamsException(message)
        for question_element in question_elements:
            self.process_question(question_element, question_set_code)
        return
Beispiel #9
0
 def output(self):
     """
     Output the HTML to its file.
     """
     file = None
     try:
         file = open(self._filename, 'w')
         result = TestCase.prettify(self._html)
         file.write(result)
     except Exception as e:
         raise SuiteDreamsException(e)
     finally:
         if file is not None:
             file.close()
     return
Beispiel #10
0
    def add_create_umbrella(self, entity_type, limit):
        """
        Add a line for:

        create umbrella <entity_type> with <limit>

        Arguments:
            entity_type - one of: exposure, question, member, driver
            limit - the limit for the umbrella coverage
        """
        values = ["exposure", "question", "member", "driver", "policy"]
        if entity_type not in values:
            raise SuiteDreamsException("Umbrella entity type is invalid -" + entity_type)
        row = ["create", "umbrella", entity_type, "with", limit]
        self.test_case.add_row(row)
        return
Beispiel #11
0
    def process_coverables(self, product_element):
        """
        Process the sset of coverables.

        Arguments:
            product_element - the <Product> element
        """
        coverable_elements = self.product_spec.fetch_all_elements(product_element, "Coverable")
        if len(coverable_elements) == 0:
            message = "Product must have at least one coverable"
            raise SuiteDreamsException(message)
        for coverable_element in coverable_elements:
            selector = self.random_selector
            if FileBuilder.select_element(coverable_element, selector):
                self.process_coverable(coverable_element)
        return
Beispiel #12
0
def validate_test_suite_dir(test_suite_library, suite_name):
    """
    Verify that the test suite directory does not exist yeet.
    Then create it.

    Arguments:
         test_suite_library - the diretory that holds test suites.
         suite_name - the name of the test suite.  This will be the name of the subdirectory in
            the test suite library
    """
    if suite_name is None or len(suite_name) == 0:
        raise SuiteDreamsException(
            "Test suite name must not be None or an empty string")
    test_suite_dir = test_suite_library + "/" + suite_name
    path = Path(test_suite_dir)
    if path.exists():
        print("Test suite directory already exists - " + test_suite_dir)
    else:
        path.mkdir(mode=0o777, parents=False, exist_ok=False)
    return
Beispiel #13
0
    def fetch_element(parent, tag):
        """
        Return the single element named in the tag argument. This method should be used only when
        only one element with this name is used.  If the element is not found, an exception
        is thrown.

        Argument:
            parent - the parent of the element being searched for
            tag - the name of the element to be retrieved

        Returns:
            The element being searched for.
        """
        assert tag is not None, "fetch_element: Tag must not be None"
        assert len(tag) > 0, "fetch_element: Tag must not be an empty string"
        assert parent is not None, "fetch_element: Parent of element " + tag + " must not be None"
        element = parent.find(tag)
        if element is None:
            message = "fetch_element: Element " + tag + " was not found in element " + parent.tag
            raise SuiteDreamsException(message)
        return element
Beispiel #14
0
    def process_values(self, property_element, property_name, element_name):
        """
        Select a value from a list of values of a property.

        Argument:
            property_element - the property element containig the values
            property_name - the name of the property or question
            element_name - the name of the element containing values
        """
        assert element_name is not None, "process_values: element name must not be None"
        assert len(element_name) > 0, "process_values: element name must not be an empty string"
        selector = self.random_selector
        value_elements = self.product_spec.fetch_all_elements(property_element, element_name)
        sum_weights = 0
        for value_element in value_elements:
            weight = FileBuilder.fetch_weight(value_element)
            sum_weights += weight
            if selector <= sum_weights:
                return value_element.text
        message = "No values were selected for - " + property_name + ". Element being searched is - " + element_name
        raise SuiteDreamsException(message)