def test_post_validation_success(self):
     os.environ['SSH_AUTH_SOCK'] = 'something'
     config = config_parse.valid_ssh_options.validate(
         self.config,
         self.context,
     )
     assert_equal(config.agent, True)

 def test_perform_with_params(self):
     assert_equal(self.proxy.perform('equals')(2), [False, True, False])
     sometimes = ['sometimes'] * 3
     assert_equal(
         self.proxy.perform('equals')(3, sometimes=True),
         sometimes,
     )

 def test_configure_from_dict(self):
     config_data = {
         'scribe_host': 'example.com',
         'scribe_port': '5555'
     }
     config.configure_from_dict(config_data)
     T.assert_equal(config.scribe_host, config_data['scribe_host'])

 def test_from_config(self):
     config = mock.Mock()
     runner_factory = actioncommand.SubprocessActionRunnerFactory.from_config(
         config,
     )
     assert_equal(runner_factory.status_path, config.remote_status_path)
     assert_equal(runner_factory.exec_path, config.remote_exec_path)

 def test_attributes(self):
     expected = make_named_tron_config(
         jobs={
             'test_job':
                 make_job(
                     name="test_job",
                     namespace='test_namespace',
                     schedule=ConfigIntervalScheduler(
                         timedelta=datetime.timedelta(0, 20),
                         jitter=None,
                     ),
                     expected_runtime=datetime.timedelta(1),
                 )
         }
     )
     test_config = validate_fragment(
         'test_namespace',
         dict(
             jobs=[
                 dict(
                     name="test_job",
                     namespace='test_namespace',
                     node="node0",
                     schedule="interval 20s",
                     actions=[dict(name="action", command="command")],
                     cleanup_action=dict(command="command"),
                 )
             ]
         )
     )
     assert_equal(test_config, expected)

 def test_from_config(self):
     name = 'the pool name'
     nodes = [create_mock_node(), create_mock_node()]
     config = mock.Mock(name=name)
     new_pool = node.NodePool.from_config(config, nodes)
     assert_equal(new_pool.name, config.name)
     assert_equal(new_pool.nodes, nodes)

 def test_wildcards(self):
     cfg = parse_groc('every day')
     assert_equal(cfg.ordinals, None)
     assert_equal(cfg.monthdays, None)
     assert_equal(cfg.weekdays, None)
     assert_equal(cfg.months, None)
     assert_equal(cfg.timestr, '00:00')

 def test_get_url_from_identifier_job(self):
     identifier = get_object_type_from_identifier(
         self.index,
         'MASTER.namea',
     )
     assert_equal(identifier.url, '/api/jobs/MASTER.namea')
     assert_equal(identifier.type, TronObjectType.job)

    def test__getitem__last_success(self):
        item = self.context["last_success#day-1"]
        expected_date = self.last_success.run_time - datetime.timedelta(days=1)
        assert_equal(item, str(expected_date.day))

        item = self.context["last_success#shortdate"]
        assert_equal(item, "2012-03-14")

 def test_notify(self):
     handler = mock.MagicMock()
     self.obs.attach(['a', 'b'], handler)
     self.obs.notify('a')
     assert_equal(len(handler.handler.mock_calls), 1)
     self.obs.notify('b')
     assert_equal(len(handler.handler.mock_calls), 2)

    def test_attach(self):
        def func():
            return 1

        self.obs.attach('a', func)
        assert_equal(len(self.obs._observers), 1)
        assert_equal(self.obs._observers['a'], [func])

 def test_get_url_from_identifier_action_run(self):
     identifier = get_object_type_from_identifier(
         self.index,
         'MASTER.nameb.7.run',
     )
     assert_equal(identifier.url, '/api/jobs/MASTER.nameb/7/run')
     assert_equal(identifier.type, TronObjectType.action_run)

    def test_cancel_schedules_a_new_run(self):
        config = BASIC_CONFIG + dedent(
            """
            jobs:
                -   name: "a_job"
                    node: local
                    schedule: "daily 05:00:00"
                    actions:
                        -   name: "first_action"
                            command: "echo OK"
        """
        )
        self.start_with_config(config)
        job_name = 'MASTER.a_job'
        job_url = self.client.get_url(job_name)

        self.sandbox.tronctl('cancel', '%s.0' % job_name)

        def wait_on_cancel():
            return len(self.client.job(job_url)['runs']) == 2

        sandbox.wait_on_sandbox(wait_on_cancel)

        run_states = [run['state'] for run in self.client.job(job_url)['runs']]
        expected = [
            actionrun.ActionRun.SCHEDULED,
            actionrun.ActionRun.CANCELLED,
        ]
        assert_equal(run_states, expected)

 def test_read_raw_config(self):
     name = 'name'
     path = os.path.join(self.temp_dir, name)
     manager.write(path, self.content)
     self.manifest.get_file_name.return_value = path
     config = self.manager.read_raw_config(name)
     assert_equal(config, yaml.dump(self.content))

 def test_parse_no_month(self):
     cfg = parse_groc('1st,2nd,3rd,10th day at 00:00')
     assert_equal(cfg.ordinals, None)
     assert_equal(cfg.monthdays, {1, 2, 3, 10})
     assert_equal(cfg.weekdays, None)
     assert_equal(cfg.months, None)
     assert_equal(cfg.timestr, '00:00')

    def test_next_day_weekdays(self):
        time_spec = trontimespec.TimeSpecification(weekdays=[1, 5])
        gen = time_spec.next_day(14, 2012, 3)
        assert_equal(list(gen), [16, 19, 23, 26, 30])

        gen = time_spec.next_day(1, 2012, 3)
        assert_equal(list(gen), [2, 5, 9, 12, 16, 19, 23, 26, 30])

    def test_get_next_to_finish_none(self):
        next_run = self.run_collection.get_next_to_finish(node="seven")
        assert_equal(next_run, None)

        self.job_runs[1].state = None
        next_run = self.run_collection.get_next_to_finish()
        assert_equal(next_run, None)

    def test_next_day_monthdays(self):
        time_spec = trontimespec.TimeSpecification(monthdays=[5, 10, 15])
        gen = time_spec.next_day(14, 2012, 3)
        assert_equal(list(gen), [15])

        gen = time_spec.next_day(1, 2012, 3)
        assert_equal(list(gen), [5, 10, 15])

    def test_trond_restart_job_with_run_history(self):
        config = BASIC_CONFIG + textwrap.dedent(
            """
           jobs:
              - name: fast_job
                node: local
                schedule: constant
                actions:
                  - name: single_act
                    command: "sleep 20 && echo good"
        """
        )
        self.start_with_config(config)

        action_run_url = self.client.get_url('MASTER.fast_job.0.single_act')
        sandbox.wait_on_state(
            self.client.action_runs,
            action_run_url,
            actionrun.ActionRun.RUNNING,
        )

        self.restart_trond()

        assert_equal(
            self.client.job_runs(action_run_url)['state'],
            actionrun.ActionRun.UNKNOWN,
        )

        next_run_url = self.client.get_url('MASTER.fast_job.-1.single_act')
        sandbox.wait_on_state(
            self.client.action_runs,
            next_run_url,
            actionrun.ActionRun.RUNNING,
        )

 def test_repr(self, mock_many):
     result = self.adapter.get_repr()
     assert_equal(result['name'], self.pool.get_name.return_value)
     mock_many.assert_called_with(
         adapter.NodeAdapter,
         self.pool.get_nodes.return_value,
     )