Beispiel #1
0
    def teardown_method(self):
        self.stop()

        # check unit.log for alerts

        unit_log = self.temp_dir + '/unit.log'

        with open(unit_log, 'r', encoding='utf-8', errors='ignore') as f:
            _check_alerts(f.read())

        # remove unit.log

        if not option.save_log:
            shutil.rmtree(self.temp_dir)
        else:
            _print_log(path=self.temp_dir)

        assert self.stop_errors == [None, None], 'stop errors'
Beispiel #2
0
    def _run(self):
        build_dir = option.current_dir + '/build'
        self.unitd = build_dir + '/unitd'

        if not os.path.isfile(self.unitd):
            exit("Could not find unit")

        self.temp_dir = tempfile.mkdtemp(prefix='unit-test-')

        public_dir(self.temp_dir)

        if oct(stat.S_IMODE(os.stat(build_dir).st_mode)) != '0o777':
            public_dir(build_dir)

        os.mkdir(self.temp_dir + '/state')

        with open(self.temp_dir + '/unit.log', 'w') as log:
            self._p = subprocess.Popen(
                [
                    self.unitd,
                    '--no-daemon',
                    '--modules',
                    build_dir,
                    '--state',
                    self.temp_dir + '/state',
                    '--pid',
                    self.temp_dir + '/unit.pid',
                    '--log',
                    self.temp_dir + '/unit.log',
                    '--control',
                    'unix:' + self.temp_dir + '/control.unit.sock',
                    '--tmp',
                    self.temp_dir,
                ],
                stderr=log,
            )

        atexit.register(self.stop)

        if not waitforfiles(self.temp_dir + '/control.unit.sock'):
            _print_log(path=self.temp_dir + '/unit.log')
            exit("Could not start unit")

        self._started = True
Beispiel #3
0
    def setup_class(cls, complete_check=True):
        cls.available = option.available
        unit = TestUnit()

        unit._run()

        # read unit.log

        for i in range(50):
            with open(unit.temp_dir + '/unit.log', 'r') as f:
                log = f.read()
                m = re.search('controller started', log)

                if m is None:
                    time.sleep(0.1)
                else:
                    break

        if m is None:
            _print_log(path=unit.temp_dir + '/unit.log')
            exit("Unit is writing log too long")

        def check(available, prerequisites):
            missed = []

            # check modules

            if 'modules' in prerequisites:
                available_modules = list(available['modules'].keys())

                for module in prerequisites['modules']:
                    if module in available_modules:
                        continue

                    missed.append(module)

            if missed:
                pytest.skip('Unit has no ' + ', '.join(missed) + ' module(s)')

            # check features

            if 'features' in prerequisites:
                available_features = list(available['features'].keys())

                for feature in prerequisites['features']:
                    if feature in available_features:
                        continue

                    missed.append(feature)

            if missed:
                pytest.skip(', '.join(missed) + ' feature(s) not supported')

        def destroy():
            unit.stop()
            _check_alerts(log)
            shutil.rmtree(unit.temp_dir)

        def complete():
            destroy()
            check(cls.available, cls.prerequisites)

        if complete_check:
            complete()
        else:
            unit.complete = complete
            return unit