TestResultModels.py

from django.db import models
from functools import reduce

class Result:
    passed = 1
    failed = 2
    skipped = 3

def count_results(results, result):
    return reduce(lambda accum, current: accum + (current.result_id == result),
                    results, 0)

def count_all_results(results):
    return (count_results(results, Result.passed),
            count_results(results, Result.failed),
            count_results(results, Result.skipped))

class Automation(models.Model):
    name = models.CharField('the source of the Test Run', max_length=200)
    silo = models.CharField(max_length=10)

    def __str__ (self):
        return self.name

    def get_silos():
        return Automation.objects \
            .values_list('silo',flat=True) \
            .distinct()

    def get_afts_for_silo(silo):
        return Automation.objects \
            .filter(silo__exact=silo) \
            .distinct()

    def get_silo_overview(silo):
        automations = Automation.get_afts_for_silo(silo)
        features = Feature.objects \
            .filter(automation_id__in=automations) \
            .distinct()
        scenarios = Scenario.objects \
            .filter(feature_id__in=features) \
            .distinct()
        tests = TestRunResult.objects.filter(automation__in=automations)
        return (len(automations), len(features), len(scenarios),
                *count_all_results(tests), len(tests))

    def get_aft_overview(self):
        features = Feature.objects \
            .filter(automation_id__exact=self) \
            .distinct()
        scenarios = Scenario.objects \
            .filter(feature_id__in=features) \
            .distinct()
        tests = TestRunResult.objects.filter(automation_id__exact=self)
        return (len(features), len(scenarios), *count_all_results(tests), len(tests))

    def get_features(self):
        return Feature.objects.filter(automation_id__exact=self)

class TestRun(models.Model):
    automation = models.ForeignKey(Automation, on_delete=models.CASCADE)
    run_author = models.CharField('Author', max_length=50)
    run_date = models.DateTimeField('Date Run')
    run_env = models.CharField('Test Environment', max_length=10)
    run_type = models.CharField('Test Type', max_length=20)

    def get_features(self):
        pks = TestRunResult.objects \
            .filter(test_run__exact=self.pk) \
            .values_list('feature_id', flat=True) \
            .distinct()
        return Feature.objects.filter(id__in=pks)

    def get_scenarios_for_feature(self, feature):
        test_run_result = TestRunResult.objects \
            .filter(test_run__exact=self.pk) \
            .filter(feature_id__exact=feature.pk) \
            .order_by('id')
        pks = test_run_result \
            .values_list('scenario_id', flat=True) \
            .distinct()
        scenarios = Scenario.objects.filter(id__in=pks)
        return { scenario : test_run_result.filter(scenario_id__exact=scenario) \
                for scenario in scenarios }

    def get_run_overview(self):
        tests = TestRunResult.objects.filter(test_run__exact=self.pk)
        return (*count_all_results(tests), len(tests))

class Feature(models.Model):
    automation = models.ForeignKey(Automation, on_delete = models.CASCADE)
    name = models.CharField(max_length=200)

    def __str__ (self):
        return self.name

    def get_feature_overview(self):
        scenarios = Scenario.objects \
            .filter(feature_id__exact=self) \
            .distinct()
        tests = TestRunResult.objects.filter(feature_id__exact=self)
        return (len(scenarios), *count_all_results(tests), len(tests))

    def get_latest_testrun(self):
        return TestRunResult.objects \
            .filter(feature_id__exact=self) \
            .latest('test_run') \
            .test_run

class Scenario(models.Model):
    feature = models.ForeignKey(Feature, on_delete = models.CASCADE)
    name = models.CharField(max_length=400)
    unique_id=models.CharField(max_length=400)

    def __str__ (self):
        return self.name

class Step(models.Model):
    scenario = models.ForeignKey(Scenario, on_delete = models.CASCADE)
    name = models.TextField('Step Description')
    gherkin = models.CharField(max_length=10)

    def __str__ (self):
        return self.name

class TestResult(models.Model):
    result = models.CharField(max_length=10)

    def __str__ (self):
        return self.result

class TestRunResult(models.Model):
    step = models.ForeignKey(Step, on_delete = models.CASCADE)
    scenario = models.ForeignKey(Scenario, on_delete=models.CASCADE, default=1)
    feature = models.ForeignKey(Feature, on_delete=models.CASCADE, default=1)
    automation = models.ForeignKey(Automation, on_delete=models.CASCADE, default=1)
    test_run = models.ForeignKey(TestRun, on_delete = models.CASCADE)
    result = models.ForeignKey(TestResult, on_delete = models.CASCADE)
    run_date = models.DateTimeField('date run')
    error_message = models.TextField(blank=True)

    def __str__ (self):
return self.error_message