def test_with_one_job_flow(self):
        emr_conn = boto.emr.connection.EmrConnection()
        emr_conn.run_jobflow('no name', log_uri=None)

        self.monkey_patch_stdout()
        main(['-q', '--no-conf'])
        self.assertIn(b'j-MOCKJOBFLOW0', sys.stdout.getvalue())

    def test_with_one_cluster(self):
        emr_conn = boto.emr.connection.EmrConnection()
        emr_conn.run_jobflow("no name", job_flow_role="fake-instance-profile", service_role="fake-service-role")

        self.monkey_patch_stdout()
        main(["-q", "--no-conf"])
        self.assertIn(b"j-MOCKCLUSTER0", sys.stdout.getvalue())

    def test_with_one_cluster(self):
        emr_conn = boto.emr.connection.EmrConnection()
        emr_conn.run_jobflow('no name', job_flow_role='fake-instance-profile',
                             service_role='fake-service-role')

        self.monkey_patch_stdout()
        main(['-q', '--no-conf'])
        self.assertIn(b'j-MOCKCLUSTER0', sys.stdout.getvalue())

    def test_with_one_cluster(self):
        emr_client = boto3.client('emr')
        emr_client.run_job_flow(
            Name='no name',
            Instances=dict(
                MasterInstanceType='m1.medium',
                InstanceCount=1),
            JobFlowRole='fake-instance-profile',
            ServiceRole='fake-service-role',
            ReleaseLabel='emr-5.0.0')

        self.monkey_patch_stdout()
        main(['-q', '--no-conf'])
        self.assertIn(b'j-MOCKCLUSTER0', sys.stdout.getvalue())

        self.assertTrue(self.repeat_sleep.called)
        self.assertEqual(self.describe_cluster_sleep.call_count, 1)

def audit_usage(args):
    from mrjob.tools.emr.audit_usage import main
    main(args)

def terminate_cluster(args):
    from mrjob.tools.emr.terminate_cluster import main
    main(args)

def terminate_jf(args):
    from mrjob.tools.emr.terminate_job_flow import main
    main(args)

def s3_tmpwatch(args):
    from mrjob.tools.emr.s3_tmpwatch import main
    main(args)

def terminate_idle_jfs(args):
    from mrjob.tools.emr.terminate_idle_job_flows import main
    main(args)

def mrboss(args):
    from mrjob.tools.emr.mrboss import main
    main(args)

 def test_with_no_job_flows(self):
     self.monkey_patch_stdout()
     main(['-q', '--no-conf'])  # just make sure it doesn't crash

    def test_with_no_clusters(self):
        self.monkey_patch_stdout()
        main(['-q', '--no-conf'])  # make sure it doesn't crash

        self.assertTrue(self.repeat_sleep.called)
        self.assertFalse(self.describe_cluster_sleep.called)

    def test_with_one_job_flow(self):
        emr_conn = boto_2_1_1_83aae37b.EmrConnection()
        emr_conn.run_jobflow('no name', log_uri=None)

        main(['-q', '--no-conf'])
        self.assertIn('j-MOCKJOBFLOW0', self.stdout.getvalue())

def collect_emr_stats(args):
    from mrjob.tools.emr.collect_emr_stats import main
    main(args)

def fetch_logs(args):
    from mrjob.tools.emr.fetch_logs import main
    main(args)

def _spark_submit(args):
    from mrjob.tools.spark_submit import main
    main(args)

 def test_with_no_clusters(self):
     self.monkey_patch_stdout()
     main(["-q", "--no-conf"])  # just make sure it doesn't crash

def _terminate_idle_clusters(args):
    from mrjob.tools.emr.terminate_idle_clusters import main
    main(args)

def create_cluster(args):
    from mrjob.tools.emr.create_cluster import main
    main(args)

@command('terminate-idle-clusters', 'Terminate idle EMR clusters')
def terminate_idle_clusters(args):
    from mrjob.tools.emr.terminate_idle_clusters import main
    main(args)


# deprecated alias for terminate-idle-clusters, delete in v0.6.0
@command('terminate-idle-job-flows')
def terminate_idle_jfs(args):
    from mrjob.tools.emr.terminate_idle_job_flows import main
    main(args)


@command('terminate-cluster', 'Terminate a single EMR cluster')
def terminate_cluster(args):
    from mrjob.tools.emr.terminate_cluster import main
    main(args)


# deprecated alias for terminate-cluster, delete in v0.6.0
@command('terminate-job-flow')
def terminate_jf(args):
    from mrjob.tools.emr.terminate_job_flow import main
    main(args)


if __name__ == '__main__':
    main()