def it_fails_with_multiple_services():
    assert_command(
        ('pgctl-2015', 'debug', 'abc', 'def'),
        '',
        '[pgctl] ERROR: Must debug exactly one service, not: abc, def\n',
        1,
    )

    def it_can_be_run_via_python_m(self, tmpdir):
        from sys import executable
        expected_output = '''\
{
    "app": "app",
    "app/a": "app/a",
    "app/b": "app/b",
    "apps": [
        "1",
        "2",
        "3"
    ],
    "environ": "environ",
    "environs": [
        "1",
        "2",
        "3"
    ],
    "etc": "etc",
    "home": "home"
}
'''
        with setup(tmpdir):
            assert_command(
                (executable, '-m', 'pgctl.config', 'my'),
                expected_output,
                '',
                0,
                norm=norm_trailing_whitespace_json,
            )

def it_restarts_on_unready():

    def it_is_ready():
        assert_svstat('playground/slow-startup', state='ready')

    def it_becomes_unready():
        from testfixtures import Comparison as C
        from pgctl.daemontools import svstat
        assert svstat('playground/slow-startup') != C(SvStat, {'state': 'ready'}, strict=False)

    it_can_succeed()
    os.remove('playground/slow-startup/readyfile')
    wait_for(it_becomes_unready)
    wait_for(it_is_ready)

    assert_command(
        ('pgctl-2015', 'log'),
        '''\
==> playground/slow-startup/log <==
{TIMESTAMP} pgctl-poll-ready: service's ready check succeeded
{TIMESTAMP} pgctl-poll-ready: service's ready check failed -- we are restarting it for you
{TIMESTAMP} [pgctl] Stopping: slow-startup
{TIMESTAMP} [pgctl] Stopped: slow-startup
{TIMESTAMP} [pgctl] Starting: slow-startup
{TIMESTAMP} pgctl-poll-ready: service's ready check succeeded
{TIMESTAMP} [pgctl] Started: slow-startup
''',
        '',
        0,
        norm=norm.pgctl,
    )

def it_times_out():
    assert_command(
        ('pgctl-2015', 'start'),
        '''\
''',
        '''\
[pgctl] Starting: slow-startup
[pgctl] ERROR: service 'slow-startup' failed to start after {TIME} seconds, its status is up (pid {PID}) {TIME} seconds
==> playground/slow-startup/log <==
[pgctl] Stopping: slow-startup
[pgctl] Stopped: slow-startup
[pgctl] ERROR: Some services failed to start: slow-startup
''',
        1,
        norm=norm.pgctl,
    )
    assert_svstat('playground/slow-startup', state=SvStat.UNSUPERVISED)

    assert_command(
        ('pgctl-2015', 'log'),
        '''\
==> playground/slow-startup/log <==
{TIMESTAMP} pgctl-poll-ready: service is stopping -- quitting the poll
''',
        '',
        0,
        norm=norm.pgctl,
    )

    def it_shows_error_on_stop_for_sweet(self):
        check_call(('pgctl', 'start', 'sweet'))
        assert_command(
            ('pgctl', 'restart', 'sweet'),
            '',
            '''\
[pgctl] Stopping: sweet
[pgctl] ERROR: service 'sweet' failed to stop after {TIME} seconds, these runaway processes did not stop:
{PS-HEADER}
{PS-STATS} sleep infinity

There are two ways you can fix this:
  * temporarily: pgctl stop sweet --force
  * permanently: http://pgctl.readthedocs.org/en/latest/user/quickstart.html#writing-playground-services

==> playground/sweet/logs/current <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
[pgctl]
[pgctl] There might be useful information further up in the log; you can view it by running:
[pgctl]     less +G playground/sweet/logs/current
[pgctl] ERROR: Some services failed to stop: sweet
''',
            1,
            norm=norm.pgctl,
        )

    def it_starts_up_fine(self):
        assert_command(
            ('pgctl', 'start'),
            '',
            '''\
[pgctl] Starting: slow-startup, sweet
[pgctl] Started: sweet
[pgctl] Started: slow-startup
''',
            0,
        )
        assert_command(
            ('pgctl', 'log'),
            '''\
==> playground/slow-startup/logs/current <==
{TIMESTAMP} pgctl-poll-ready: service's ready check succeeded

==> playground/sweet/logs/current <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
''',
            '',
            0,
            norm=norm.pgctl,
        )

def it_fails_twice_but_doesnt_restart():

    def it_is_ready():
        assert_svstat('playground/unreliable', state='ready')

    assert_command(
        ('pgctl-2015', 'start'),
        '',
        '[pgctl] Starting: unreliable\n[pgctl] Started: unreliable\n',
        0
    )
    wait_for(it_is_ready)

    assert_command(
        ('pgctl-2015', 'log'),
        '''\
==> playground/unreliable/log <==
{TIMESTAMP} pgctl-poll-ready: service's ready check succeeded
{TIMESTAMP} pgctl-poll-ready: failed (restarting in 2.00 seconds)
{TIMESTAMP} pgctl-poll-ready: failed (restarting in 1.99 seconds)
''',
        '',
        0,
        norm=norm.timestamp,
    )

 def it_can_detect_cycles(self, in_example_dir):
     assert_command(
         ("pgctl-2015", "start", "b"),
         "",
         "[pgctl] ERROR: Circular aliases! Visited twice during alias expansion: 'b'\n",
         1,
     )

    def it_can_accept_different_environment_variables(self, in_example_dir):
        check_call(('sh', '-c', 'MYVAR=ohhi pgctl start'))

        assert_command(
            ('pgctl', 'log'),
            '''\
==> playground/environment/logs/current <==
{TIMESTAMP} ohhi
''',
            '',
            0,
            norm=norm.pgctl,
        )

        check_call(('sh', '-c', 'MYVAR=bye pgctl restart'))

        assert_command(
            ('pgctl', 'log'),
            '''\
==> playground/environment/logs/current <==
{TIMESTAMP} ohhi
{TIMESTAMP} bye
''',
            '',
            0,
            norm=norm.pgctl,
        )

 def it_can_detect_cycles(self, in_example_dir):
     assert_command(
         ('pgctl', 'start', 'b'),
         '',
         "[pgctl] ERROR: Circular aliases! Visited twice during alias expansion: 'b'\n",
         1,
     )

    def it_shows_error_on_stop_for_sweet(self):
        assert_command(
            ('pgctl-2015', 'start', 'sweet'),
            '',
            '''\
[pgctl] Starting: sweet
[pgctl] Started: sweet
''',
            0,
        )
        assert_command(
            ('pgctl-2015', 'restart', 'sweet'),
            '',
            '''\
[pgctl] Stopping: sweet
[pgctl] ERROR: service 'sweet' failed to stop after {TIME} seconds, these runaway processes did not stop:
{PS-HEADER}
{PS-STATS} sleep infinity

There are two ways you can fix this:
  * temporarily: lsof -t playground/sweet | xargs kill -9
  * permanently: http://pgctl.readthedocs.org/en/latest/user/quickstart.html#writing-playground-services

==> playground/sweet/log <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
[pgctl] ERROR: Some services failed to stop: sweet
''',
            1,
            norm=norm.pgctl,
        )

    def it_can_still_show_config(self, tmpdir):
        expected_output = '''\
{
    "aliases": {
        "default": [
            "(all services)"
        ]
    },
    "command": "config",
    "force": false,
    "json": false,
    "pgdir": "playground",
    "pghome": "~/.run/pgctl",
    "poll": ".01",
    "services": [
        "default"
    ],
    "timeout": "2.0",
    "verbose": false
}
'''

        with tmpdir.as_cwd():
            assert_command(
                ('pgctl', 'config'),
                expected_output,
                '',
                0,
                norm=norm_trailing_whitespace_json,
            )

    def it_shows_stdout_and_stderr(self, in_example_dir):
        check_call(('pgctl', 'start', 'sweet'))

        assert_command(
            ('pgctl', 'log'),
            '''\
==> playground/ohhi/logs/current <==

==> playground/sweet/logs/current <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
''',
            '',
            0,
            norm=norm.pgctl,
        )

        check_call(('pgctl', 'restart', 'sweet'))

        assert_command(
            ('pgctl', 'log'),
            '''\
==> playground/ohhi/logs/current <==

==> playground/sweet/logs/current <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
''',
            '',
            0,
            norm=norm.pgctl,
        )

    def it_works(self, in_example_dir):
        assert_command(
            ('pgctl', 'start', 'A'),
            '',
            '''\
[pgctl] Starting: A
[pgctl] Started: A
''',
            0,
        )
        wait_for(lambda: assert_command(
            ('pgctl', 'log', 'A'),
            '''\
==> playground/A/logs/current <==
{TIMESTAMP} [pgctl] Starting: B
{TIMESTAMP} [pgctl] DEBUG: parentlock: '%s/playground/A'
{TIMESTAMP} [pgctl] DEBUG: LOCK: ${LOCK}
{TIMESTAMP} [pgctl] DEBUG: loop: check_time $TIME
{TIMESTAMP} [pgctl] Started: B
{TIMESTAMP} this is stdout
{TIMESTAMP} this is stderr
''' % in_example_dir,
            '',
            0,
            norm=norm.pgctl,
        ))
        assert_command(
            ('pgctl', 'stop', 'A'),
            '',
            '''\
[pgctl] Stopping: A
[pgctl] Stopped: A
''',
            0,
        )

    def it_can_still_show_help(self, tmpdir):
        with tmpdir.as_cwd():
            assert_command(
                ('pgctl', '--help'),
                '''\
usage: pgctl [-h] [--version] [--verbose] [--pgdir PGDIR] [--pghome PGHOME]
             [--json] [--force] [--all]
             {start,stop,status,restart,reload,log,debug,config}
             [services [services ...]]

positional arguments:
  {start,stop,status,restart,reload,log,debug,config}
                        specify what action to take
  services              specify which services to act upon

optional arguments:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  --verbose             show additional service action information
  --pgdir PGDIR         name the playground directory
  --pghome PGHOME       directory to keep user-level playground state
  --json                output in JSON (only supported by some commands)
  --force               forcefully terminate runaway processes that prevent
                        services from starting/stopping
  --all, -a             act upon all services
''',
                '',
                0,
            )

def assert_does_not_find(path):
    assert_command(
        ('pgctl-fuser', path),
        '',
        '',
        0,
    )

    def it_runs_before_starting_a_service(self):
        assert_command(
            ('pgctl', 'start'),
            'hello, i am a pre-start script in stdout\n',
            '''\
hello, i am a pre-start script in stderr
--> $PWD basename: pre-start-hook
--> cwd basename: pre-start-hook
[pgctl] Starting: sweet
[pgctl] Started: sweet
''',
            0,
            norm=norm.pgctl,
        )

        # starting when already up doesn't trigger pre-start to run again
        assert_command(
            ('pgctl', 'start'),
            '',
            '''\
[pgctl] Already started: sweet
''',
            0,
            norm=norm.pgctl,
        )

    def it_can_accept_different_environment_variables(self, in_example_dir):
        check_call(("sh", "-c", "MYVAR=ohhi pgctl-2015 start"))

        assert_command(
            ("pgctl-2015", "log"),
            """\
==> playground/environment/log <==
{TIMESTAMP} ohhi
""",
            "",
            0,
            norm=norm.pgctl,
        )

        check_call(("sh", "-c", "MYVAR=bye pgctl-2015 restart"))

        assert_command(
            ("pgctl-2015", "log"),
            """\
==> playground/environment/log <==
{TIMESTAMP} ohhi
{TIMESTAMP} bye
""",
            "",
            0,
            norm=norm.pgctl,
        )

    def it_shows_error_on_stop_for_slow_start(self):
        assert_command(
            ('pgctl-2015', 'start', 'slow-startup'),
            '',
            '''\
[pgctl] Starting: slow-startup
[pgctl] Started: slow-startup
''',
            0,
        )
        assert_command(
            ('pgctl-2015', 'restart', 'slow-startup'),
            '',
            '''\
[pgctl] Stopping: slow-startup
[pgctl] ERROR: service 'slow-startup' failed to stop after {TIME} seconds, these runaway processes did not stop:
{PS-HEADER}
{PS-STATS} sleep 987654

There are two ways you can fix this:
  * temporarily: lsof -t playground/slow-startup | xargs kill -9
  * permanently: http://pgctl.readthedocs.org/en/latest/user/quickstart.html#writing-playground-services

==> playground/slow-startup/log <==
{TIMESTAMP} pgctl-poll-ready: service's ready check succeeded
{TIMESTAMP} pgctl-poll-ready: service is stopping -- quitting the poll
[pgctl] ERROR: Some services failed to stop: slow-startup
''',
            1,
            norm=norm.pgctl,
        )

    def it_shows_stdout_and_stderr(self, in_example_dir):
        check_call(("pgctl-2015", "start", "sweet"))

        assert_command(
            ("pgctl-2015", "log"),
            """\
==> playground/ohhi/log <==

==> playground/sweet/log <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
""",
            "",
            0,
            norm=norm.pgctl,
        )

        check_call(("pgctl-2015", "restart", "sweet"))

        assert_command(
            ("pgctl-2015", "log"),
            """\
==> playground/ohhi/log <==

==> playground/sweet/log <==
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
{TIMESTAMP} sweet
{TIMESTAMP} sweet_error
""",
            "",
            0,
            norm=norm.pgctl,
        )