def test_valid_cleanup_action_name_fail(self):
     assert_raises(
         ConfigError,
         valid_cleanup_action_name,
         'other',
         NullConfigContext,
     )

 def test_set_action_runs_duplicate(self):
     run_collection = mock.create_autospec(actionrun.ActionRunCollection)
     assert_raises(
         ValueError,
         self.job_run._set_action_runs,
         run_collection,
     )

    def test_disabled_with_exception(self):
        def testfunc():
            with self.manager.disabled():
                raise ValueError()

        assert_raises(ValueError, testfunc)
        assert self.manager.enabled

 def test_create_missing_master(self):
     config_mapping = {'other': mock.Mock()}
     assert_raises(
         ConfigError,
         config_parse.ConfigContainer.create,
         config_mapping,
     )

 def test_validate_metadata_mismatch(self):
     metadata = {'version': (200, 1, 1)}
     assert_raises(
         VersionMismatchError,
         StateMetadata.validate_metadata,
         metadata,
     )

    def test_working_dir_with_exception(self):
        def with_exc():
            with tool_utils.working_dir(self.temp_dir):
                assert_equal(os.getcwd(), self.temp_dir)
                raise Exception("oops")

        assert_raises(Exception, with_exc)
        assert_equal(os.getcwd(), self.cwd)

 def test_valid_time_invalid(self):
     assert_raises(
         ConfigError,
         config_utils.valid_time,
         "14:32:12:34",
         self.context,
     )
     assert_raises(ConfigError, config_utils.valid_time, None, self.context)

 def test_valid_time_delta_invalid_unit(self):
     for jitter in ['1 year', '3 mo', '3 months']:
         assert_raises(
             ConfigError,
             config_utils.valid_time_delta,
             jitter,
             self.context,
         )

 def test_save_failed(self):
     self.store.save.side_effect = PersistenceStoreError("blah")
     assert_raises(
         PersistenceStoreError,
         self.manager.save,
         None,
         None,
         None,
     )

 def test_post_validation_failed(self):
     if 'SSH_AUTH_SOCK' in os.environ:
         del os.environ['SSH_AUTH_SOCK']
     assert_raises(
         ConfigError,
         config_parse.valid_ssh_options.validate,
         self.config,
         self.context,
     )

 def test_validate_unknown_nodes(self):
     service = {
         'name': 'some_name',
         'node': 'unknown_node',
         'command': 'do things',
         'pid_file': '/tmp',
         'monitor_interval': 30
     }
     config = {'services': [service]}
     self.container.add('third', config)
     assert_raises(ConfigError, self.container.validate)

 def test_invalid_mode(self):
     config = {
         'container_path': '/nail/srv',
         'host_path': '/tmp',
         'mode': 'RA',
     }
     assert_raises(
         ConfigError,
         config_parse.valid_volume.validate,
         config,
         self.context,
     )

 def test_missing_container_path(self):
     config = {
         'container_path_typo': '/nail/srv',
         'host_path': '/tmp',
         'mode': 'RO',
     }
     assert_raises(
         ConfigError,
         config_parse.valid_volume.validate,
         config,
         self.context,
     )

    def test_check_consistency_failed(self):
        state = {runstate.JOB_STATE: {'name': mock.Mock()}}

        with mock.patch.object(
            self.store,
            'save',
            side_effect=PersistenceStoreError,
            autospec=None,
        ):
            assert_raises(
                PersistenceStoreError,
                self.manager._check_consistency,
                state
            )

    def test_invalid_job_collation(self):
        jobs = FrozenDict({'test_collision0': ConfigJob(name='test_collision0',
            node='node0',
            schedule=ConfigIntervalScheduler(timedelta=datetime.timedelta(0,
                                                                          20)),
            actions=FrozenDict({'action0_0': ConfigAction(name='action0_0',
                                                          command='test_command0.0',
                                                          requires=(),
                                                          node=None)}),
            queueing=True,
            run_limit=50,
            all_nodes=False,
            cleanup_action=ConfigCleanupAction(command='test_command0.1',
                                               requires=(),
                                               name='cleanup',
                                               node=None),
            enabled=True,
            allow_overlap=False)})

        services = FrozenDict({'test_collision0': ConfigService(name='test_collision0',
                        node='node0',
                        pid_file='/var/run/%(name)s-%(instance_number)s.pid',
                        command='service_command0',
                        monitor_interval=20,
                        restart_interval=None,
                        count=2)})
        fake_config = mock.Mock()
        setattr(fake_config, 'jobs', jobs)
        setattr(fake_config, 'services', services)
        expected_message = "Collision found for identifier 'MASTER.test_collision0'"
        exception = assert_raises(ConfigError, collate_jobs_and_services, {'MASTER': fake_config})
        assert_in(expected_message, str(exception))

    def test_invalid_node_pool_config(self):
        test_config = dict(
            nodes=[
                dict(name='node0', hostname='node0'),
                dict(name='node1', hostname='node1')
            ],
            node_pools=[
                dict(name='pool0', hostname=['node1']),
                dict(name='pool1', nodes=['node0', 'pool0'])
            ],
            jobs=[
                dict(
                    name='test_job0',
                    node='pool1',
                    schedule='interval 20s',
                    actions=[dict(name='action', command='cmd')]
                )
            ]
        )

        expected_msg = "NodePool pool0 is missing options"
        exception = assert_raises(
            ConfigError,
            valid_config,
            test_config,
        )
        assert_in(expected_msg, str(exception))

 def test_overlap_node_and_node_pools(self):
     tron_config = dict(
         nodes=[dict(name="sameName", hostname="localhost")], node_pools=[dict(name="sameName", nodes=["sameNode"])]
     )
     expected_msg = "Node and NodePool names must be unique sameName"
     exception = assert_raises(ConfigError, valid_config, tron_config)
     assert_in(expected_msg, str(exception))

    def test_bad_requires(self):
        test_config = dict(
            jobs=[
                dict(
                    name='test_job0',
                    node='node0',
                    schedule='interval 20s',
                    actions=[dict(name='action', command='cmd')]
                ),
                dict(
                    name='test_job1',
                    node='node0',
                    schedule='interval 20s',
                    actions=[
                        dict(
                            name='action1', command='cmd', requires=['action']
                        )
                    ]
                )
            ],
            **BASE_CONFIG
        )

        expected_message = (
            'jobs.MASTER.test_job1.action1 has a dependency '
            '"action" that is not in the same job!'
        )
        exception = assert_raises(
            ConfigError,
            valid_config,
            test_config,
        )
        assert_in(expected_message, str(exception))

    def test_invalid_action_node_with_master_context(self):
        master_config = dict(
            nodes=[dict(
                name="node0",
                hostname="node0",
            )],
            node_pools=[dict(
                name="nodepool0",
                nodes=["node0"],
            )]
        )
        test_config = dict(
            jobs=[
                dict(
                    name="test_job",
                    namespace='test_namespace',
                    node="node0",
                    schedule="interval 20s",
                    actions=
                    [dict(name="action", node="nodepool1", command="command")],
                    cleanup_action=dict(command="command"),
                )
            ]
        )
        expected_message = "Unknown node name nodepool1 at test_namespace.NamedConfigFragment.jobs.Job.test_job.actions.Action.action.node"

        exception = assert_raises(
            ConfigError,
            validate_fragment,
            'test_namespace',
            test_config,
            master_config,
        )
        assert_in(expected_message, str(exception))

    def test_invalid_nested_node_pools(self):
        test_config = dict(
            nodes=[
                dict(name='node0', hostname='node0'),
                dict(name='node1', hostname='node1')
            ],
            node_pools=[
                dict(name='pool0', nodes=['node1']),
                dict(name='pool1', nodes=['node0', 'pool0'])
            ],
            jobs=[
                dict(
                    name='test_job0',
                    node='pool1',
                    schedule='constant',
                    actions=[dict(name='action', command='cmd')]
                )
            ]
        )

        expected_msg = "NodePool pool1 contains other NodePools: pool0"
        exception = assert_raises(
            ConfigError,
            valid_config,
            test_config,
        )
        assert_in(expected_msg, str(exception))