Python refstack_client.parse_cli_args函数代码示例

    def test_user_query(self, mock_input):
        client = rc.RefstackClient(rc.parse_cli_args(self.mock_argv()))
        self.assertTrue(client._user_query('42?'))

        mock_input.return_value = 'n'
        cli_args = self.mock_argv()
        cli_args.remove('-y')
        client = rc.RefstackClient(rc.parse_cli_args(cli_args))
        self.assertFalse(client._user_query('42?'))
        mock_input.return_value = 'yes'
        self.assertTrue(client._user_query('42?'))

    def test_run_tempest(self):
        """
        Test that the test command will run the tempest script using the
        default configuration.
        """
        args = rc.parse_cli_args(
            self.mock_argv(verbose='-vv', test_cases='tempest.api.compute'))
        client = rc.RefstackClient(args)
        client.tempest_dir = self.test_path
        mock_popen = self.patch(
            'refstack_client.refstack_client.subprocess.Popen',
            return_value=MagicMock(returncode=0))
        self.patch("os.path.isfile", return_value=True)
        self.mock_data()
        client.get_passed_tests = MagicMock(return_value=[{'name': 'test'}])
        client.logger.info = MagicMock()
        client._save_json_results = MagicMock()
        client.post_results = MagicMock()
        client._get_keystone_config = MagicMock(
            return_value=self.v2_config)
        client.test()

        mock_popen.assert_called_with(
            ['%s/run_tempest.sh' % self.test_path, '-C', self.conf_file_name,
             '-V', '-t', '--', 'tempest.api.compute'],
            stderr=None
        )

        self.assertFalse(client.post_results.called)

    def test_run_tempest_with_test_list(self, mock_normalize, mock_whitelist):
        """Test that the Tempest script runs with a test list file."""
        argv = self.mock_argv(verbose='-vv')
        argv.extend(['--test-list', 'test-list.txt'])
        args = rc.parse_cli_args(argv)
        client = rc.RefstackClient(args)
        client.tempest_dir = self.test_path
        mock_popen = self.patch(
            'refstack_client.refstack_client.subprocess.Popen',
            return_value=MagicMock(returncode=0))
        self.patch("os.path.isfile", return_value=True)
        self.patch("os.path.getsize", return_value=4096)
        self.mock_data()
        client.get_passed_tests = MagicMock(return_value=[{'name': 'test'}])
        client._save_json_results = MagicMock()
        client.post_results = MagicMock()
        mock_normalize.return_value = '/tmp/some-list'
        mock_whitelist.return_value = '/tmp/some-list'
        client._get_keystone_config = MagicMock(
            return_value=self.v2_config)
        client.test()

        mock_whitelist.assert_called_with('test-list.txt')
        mock_popen.assert_called_with(
            ['%s/tools/with_venv.sh' % self.test_path, 'tempest', 'run',
             '--serial', '--concurrency', '0', '--whitelist_file',
             '/tmp/some-list'],
            stderr=None
        )

    def test_run_tempest_with_test_list(self):
        """Test that the Tempest script runs with a test list file."""
        argv = self.mock_argv(verbose='-vv')
        argv.extend(['--test-list', 'test-list.txt'])
        args = rc.parse_cli_args(argv)
        client = rc.RefstackClient(args)
        client.tempest_dir = self.test_path
        mock_popen = self.patch(
            'refstack_client.refstack_client.subprocess.Popen',
            return_value=MagicMock(returncode=0))
        self.patch("os.path.isfile", return_value=True)
        self.mock_data()
        client.get_passed_tests = MagicMock(return_value=[{'name': 'test'}])
        client._save_json_results = MagicMock()
        client.post_results = MagicMock()
        lp.TestListParser.get_normalized_test_list = MagicMock(
            return_value="/tmp/some-list")
        client._get_keystone_config = MagicMock(
            return_value=self.v2_config)
        client.test()

        lp.TestListParser.get_normalized_test_list.assert_called_with(
            'test-list.txt')
        mock_popen.assert_called_with(
            ['%s/run_tempest.sh' % self.test_path, '-C', self.conf_file_name,
             '-V', '-t', '--', '--load-list', '/tmp/some-list'],
            stderr=None
        )

 def test_run_tempest_no_conf_file(self):
     """
     Test when a nonexistent configuration file is passed in.
     """
     args = rc.parse_cli_args(self.mock_argv(conf_file_name='ptn-khl'))
     client = rc.RefstackClient(args)
     self.assertRaises(SystemExit, client.test)

    def test_get_cpid_from_keystone_failure_handled(self):
        """Test that get cpid from keystone API failure handled."""
        args = rc.parse_cli_args(self.mock_argv())
        client = rc.RefstackClient(args)
        client.tempest_dir = self.test_path
        client._prep_test()
        client.logger.warning = MagicMock()
        client._generate_cpid_from_endpoint = MagicMock()
        client.conf.add_section('auth')
        client.conf.set('auth',
                        'test_accounts_file',
                        '%s/test-accounts.yaml' % self.test_path)
        self.mock_data()
        accounts = [
            {
                'tenant_name': 'tenant_name',
                'tenant_id': 'admin_tenant_id',
                'password': 'test'
            }
        ]
        self.patch(
            'refstack_client.refstack_client.read_accounts_yaml',
            return_value=accounts)
        configs = client._get_keystone_config(client.conf)
        auth_version, url, content = client._generate_keystone_data(configs)

        @httmock.urlmatch(netloc=r'(.*\.)?127.0.0.1$', path='/v2/tokens')
        def keystone_api_mock(auth_version, url, request):
            return None
        with httmock.HTTMock(keystone_api_mock):
            client._get_cpid_from_keystone(auth_version, url, content)
            client._generate_cpid_from_endpoint.assert_called_with(url)

 def test_get_cpid_from_keystone_by_tenant_name_from_account_file(self):
     """
     Test getting a CPID from Keystone using an admin tenant name
     from an accounts file.
     """
     args = rc.parse_cli_args(self.mock_argv())
     client = rc.RefstackClient(args)
     client.tempest_dir = self.test_path
     client._prep_test()
     client.conf.add_section('auth')
     client.conf.set('auth',
                     'test_accounts_file',
                     '%s/test-accounts.yaml' % self.test_path)
     self.mock_data()
     actual_result = client._get_keystone_config(client.conf)
     expected_result = None
     self.assertEqual(expected_result, actual_result['tenant_id'])
     accounts = [
         {
             'username': 'admin',
             'tenant_id': 'tenant_id',
             'password': 'test'
         }
     ]
     self.patch(
         'refstack_client.refstack_client.read_accounts_yaml',
         return_value=accounts)
     actual_result = client._get_keystone_config(client.conf)
     self.assertEqual('tenant_id', actual_result['tenant_id'])

    def test_run_tempest_upload(self):
        """
        Test that the test command will run the tempest script and call
        post_results when the --upload argument is passed in.
        """
        argv = self.mock_argv(verbose='-vv',
                              test_cases='tempest.api.compute')
        argv.insert(2, '--upload')
        args = rc.parse_cli_args(argv)
        client = rc.RefstackClient(args)
        client.tempest_dir = self.test_path
        mock_popen = self.patch(
            'refstack_client.refstack_client.subprocess.Popen',
            return_value=MagicMock(returncode=0))
        self.patch("os.path.isfile", return_value=True)
        self.mock_data()
        client.get_passed_tests = MagicMock(return_value=['test'])
        client.post_results = MagicMock()
        client._save_json_results = MagicMock()
        client._get_keystone_config = MagicMock(
            return_value=self.v2_config)
        client._get_cpid_from_keystone = MagicMock()
        client.test()
        mock_popen.assert_called_with(
            ['%s/run_tempest.sh' % self.test_path, '-C', self.conf_file_name,
             '-V', '-t', '--', 'tempest.api.compute'],
            stderr=None
        )

        self.assertTrue(client.post_results.called)

 def test_generate_keystone_data(self):
     """Test that correct data is generated."""
     args = rc.parse_cli_args(self.mock_argv())
     client = rc.RefstackClient(args)
     client.tempest_dir = self.test_path
     client._prep_test()
     client.conf.add_section('auth')
     client.conf.set('auth',
                     'test_accounts_file',
                     '%s/test-accounts.yaml' % self.test_path)
     self.mock_data()
     accounts = [
         {
             'username': 'admin',
             'tenant_id': 'admin_tenant_id',
             'password': 'test'
         }
     ]
     self.patch(
         'refstack_client.refstack_client.read_accounts_yaml',
         return_value=accounts)
     configs = client._get_keystone_config(client.conf)
     actual_results = client._generate_keystone_data(configs)
     expected_results = ('v2', 'http://0.0.0.0:35357/v2.0/tokens',
                         {'auth':
                             {'passwordCredentials':
                                 {
                                     'username': 'admin', 'password': 'test'
                                 },
                              'tenantId': 'admin_tenant_id'}})
     self.assertEqual(expected_results, actual_results)

 def test_get_keystone_config(self):
     """
     Test that keystone configs properly parsed.
     """
     args = rc.parse_cli_args(self.mock_argv())
     client = rc.RefstackClient(args)
     client.tempest_dir = self.test_path
     client._prep_test()
     client.conf.add_section('auth')
     client.conf.set('auth',
                     'test_accounts_file',
                     '%s/test-accounts.yaml' % self.test_path)
     self.mock_data()
     accounts = [
         {
             'username': 'admin',
             'tenant_name': 'tenant_name',
             'tenant_id': 'admin_tenant_id',
             'password': 'test'
         }
     ]
     self.patch(
         'refstack_client.refstack_client.read_accounts_yaml',
         return_value=accounts)
     actual_result = client._get_keystone_config(client.conf)
     expected_result = self.v2_config
     self.assertEqual(expected_result, actual_result)

    def test_yield_results(self):
        """
        Test the yield_results method, ensuring that results are retrieved.
        """
        args = rc.parse_cli_args(self.mock_argv(command='list'))
        client = rc.RefstackClient(args)
        expected_response = {
            "pagination": {
                "current_page": 1,
                "total_pages": 1
            },
            "results": [
                {
                    "cpid": "42",
                    "created_at": "2015-04-28 13:57:05",
                    "test_id": "1",
                    "url": "http://127.0.0.1:8000/output.html?test_id=1"
                },
                {
                    "cpid": "42",
                    "created_at": "2015-04-28 13:57:05",
                    "test_id": "2",
                    "url": "http://127.0.0.1:8000/output.html?test_id=2"
                }]}

        @httmock.urlmatch(netloc=r'(.*\.)?127.0.0.1$', path='/v1/results/')
        def refstack_api_mock(url, request):
            return json.dumps(expected_response)

        with httmock.HTTMock(refstack_api_mock):
            results = client.yield_results("http://127.0.0.1")
            self.assertEqual(expected_response['results'], next(results))
            self.assertRaises(StopIteration, next, results)

 def test_run_tempest_nonexisting_directory(self):
     """
     Test when the Tempest directory does not exist.
     """
     args = rc.parse_cli_args(self.mock_argv())
     client = rc.RefstackClient(args)
     client.tempest_dir = "/does/not/exist"
     self.assertRaises(SystemExit, client.test)

 def test_upload_nonexisting_file(self):
     """
     Test when the file to be uploaded does not exist.
     """
     upload_file_path = self.test_path + "/.testrepository/foo.json"
     args = rc.parse_cli_args(['upload', upload_file_path,
                               '--url', 'http://api.test.org'])
     client = rc.RefstackClient(args)
     self.assertRaises(SystemExit, client.upload)

 def test_get_next_stream_subunit_output_file_nonexistent(self):
     """
     Test getting the subunit output file from a nonexistent
     .testrepository directory.
     """
     args = rc.parse_cli_args(self.mock_argv())
     client = rc.RefstackClient(args)
     output_file = client._get_next_stream_subunit_output_file(
         "/tempest/path")
     expected_file = "/tempest/path/.testrepository/0"
     self.assertEqual(expected_file, output_file)

 def test_forbidden_conf_file(self):
     """
     Test when the user passes in a file that the user does not have
     read access to.
     """
     file = tempfile.NamedTemporaryFile()
     # Remove read access
     os.chmod(file.name, 0o220)
     args = rc.parse_cli_args(self.mock_argv(conf_file_name=file.name))
     client = rc.RefstackClient(args)
     self.assertRaises(SystemExit, client.test)