Refactoring

tests/test_auth.py

@@ -5,8 +5,8 @@ import pytest
 from httpie.plugins.builtin import HTTPBasicAuth
 from httpie.utils import ExplicitNullAuth
 from utils import http, add_auth, HTTP_OK, MockEnvironment
-import httpie.input
-import httpie.cli
+import httpie.cli.constants
+import httpie.cli.definition
 
 
 def test_basic_auth(httpbin_both):
@@ -24,7 +24,7 @@ def test_digest_auth(httpbin_both, argument_name):
     assert r.json == {'authenticated': True, 'user': 'user'}
 
 
-@mock.patch('httpie.input.AuthCredentials._getpass',
+@mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
             new=lambda self, prompt: 'password')
 def test_password_prompt(httpbin):
     r = http('--auth', 'user',
@@ -60,7 +60,7 @@ def test_only_username_in_url(url):
     https://github.com/jakubroztocil/httpie/issues/242
 
     """
-    args = httpie.cli.parser.parse_args(args=[url], env=MockEnvironment())
+    args = httpie.cli.definition.parser.parse_args(args=[url], env=MockEnvironment())
     assert args.auth
     assert args.auth.username == 'username'
     assert args.auth.password == ''
@@ -94,7 +94,7 @@ def test_ignore_netrc(httpbin_both):
 
 
 def test_ignore_netrc_null_auth():
-    args = httpie.cli.parser.parse_args(
+    args = httpie.cli.definition.parser.parse_args(
         args=['--ignore-netrc', 'example.org'],
         env=MockEnvironment(),
     )
@@ -102,7 +102,7 @@ def test_ignore_netrc_null_auth():
 
 
 def test_ignore_netrc_together_with_auth():
-    args = httpie.cli.parser.parse_args(
+    args = httpie.cli.definition.parser.parse_args(
         args=['--ignore-netrc', '--auth=username:password', 'example.org'],
         env=MockEnvironment(),
     )

tests/test_auth_plugins.py

@@ -1,6 +1,6 @@
 from mock import mock
 
-from httpie.input import SEP_CREDENTIALS
+from httpie.cli.constants import SEPARATOR_CREDENTIALS
 from httpie.plugins import AuthPlugin, plugin_manager
 from utils import http, HTTP_OK
 
@@ -83,7 +83,7 @@ def test_auth_plugin_require_auth_false_and_auth_provided(httpbin):
         auth_require = False
 
         def get_auth(self, username=None, password=None):
-            assert self.raw_auth == USERNAME + SEP_CREDENTIALS + PASSWORD
+            assert self.raw_auth == USERNAME + SEPARATOR_CREDENTIALS + PASSWORD
             assert username == USERNAME
             assert password == PASSWORD
             return basic_auth()
@@ -95,7 +95,7 @@ def test_auth_plugin_require_auth_false_and_auth_provided(httpbin):
             '--auth-type',
             Plugin.auth_type,
             '--auth',
-            USERNAME + SEP_CREDENTIALS + PASSWORD,
+            USERNAME + SEPARATOR_CREDENTIALS + PASSWORD,
         )
         assert HTTP_OK in r
         assert r.json == AUTH_OK
@@ -103,7 +103,7 @@ def test_auth_plugin_require_auth_false_and_auth_provided(httpbin):
         plugin_manager.unregister(Plugin)
 
 
-@mock.patch('httpie.input.AuthCredentials._getpass',
+@mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
             new=lambda self, prompt: 'UNEXPECTED_PROMPT_RESPONSE')
 def test_auth_plugin_prompt_password_false(httpbin):
 

tests/test_cli.py

@@ -1,42 +1,42 @@
 """CLI argument parsing related tests."""
-import json
-# noinspection PyCompatibility
 import argparse
+import json
 
 import pytest
 from requests.exceptions import InvalidSchema
 
-from httpie import input
-from httpie.input import KeyValue, KeyValueArgType, DataDict
-from httpie import ExitStatus
-from httpie.cli import parser
-from utils import MockEnvironment, http, HTTP_OK
+import httpie.cli.argparser
 from fixtures import (
-    FILE_PATH_ARG, JSON_FILE_PATH_ARG,
-    JSON_FILE_CONTENT, FILE_CONTENT, FILE_PATH
+    FILE_CONTENT, FILE_PATH, FILE_PATH_ARG, JSON_FILE_CONTENT,
+    JSON_FILE_PATH_ARG,
 )
+from httpie import ExitStatus
+from httpie.cli import constants
+from httpie.cli.definition import parser
+from httpie.cli.argtypes import KeyValueArg, KeyValueArgType
+from httpie.cli.requestitems import RequestItems
+from utils import HTTP_OK, MockEnvironment, http
 
 
 class TestItemParsing:
-
-    key_value = KeyValueArgType(*input.SEP_GROUP_ALL_ITEMS)
+    key_value_arg = KeyValueArgType(*constants.SEPARATOR_GROUP_ALL_ITEMS)
 
     def test_invalid_items(self):
         items = ['no-separator']
         for item in items:
-            pytest.raises(argparse.ArgumentTypeError, self.key_value, item)
+            pytest.raises(argparse.ArgumentTypeError, self.key_value_arg, item)
 
     def test_escape_separator(self):
-        items = input.parse_items([
+        items = RequestItems.from_args([
             # headers
-            self.key_value(r'foo\:bar:baz'),
-            self.key_value(r'jack\@jill:hill'),
+            self.key_value_arg(r'foo\:bar:baz'),
+            self.key_value_arg(r'jack\@jill:hill'),
 
             # data
-            self.key_value(r'baz\=bar=foo'),
+            self.key_value_arg(r'baz\=bar=foo'),
 
             # files
-            self.key_value(r'bar\@baz@%s' % FILE_PATH_ARG),
+            self.key_value_arg(r'bar\@baz@%s' % FILE_PATH_ARG),
         ])
         # `requests.structures.CaseInsensitiveDict` => `dict`
         headers = dict(items.headers._store.values())
@@ -45,7 +45,9 @@ class TestItemParsing:
             'foo:bar': 'baz',
             'jack@jill': 'hill',
         }
-        assert items.data == {'baz=bar': 'foo'}
+        assert items.data == {
+            'baz=bar': 'foo'
+        }
         assert 'bar@baz' in items.files
 
     @pytest.mark.parametrize(('string', 'key', 'sep', 'value'), [
@@ -54,31 +56,34 @@ class TestItemParsing:
         ('path\\==c:\\windows', 'path=', '=', 'c:\\windows'),
     ])
     def test_backslash_before_non_special_character_does_not_escape(
-            self, string, key, sep, value):
-        expected = KeyValue(orig=string, key=key, sep=sep, value=value)
-        actual = self.key_value(string)
+        self, string, key, sep, value
+    ):
+        expected = KeyValueArg(orig=string, key=key, sep=sep, value=value)
+        actual = self.key_value_arg(string)
         assert actual == expected
 
     def test_escape_longsep(self):
-        items = input.parse_items([
-            self.key_value(r'bob\:==foo'),
+        items = RequestItems.from_args([
+            self.key_value_arg(r'bob\:==foo'),
         ])
-        assert items.params == {'bob:': 'foo'}
+        assert items.params == {
+            'bob:': 'foo'
+        }
 
     def test_valid_items(self):
-        items = input.parse_items([
-            self.key_value('string=value'),
-            self.key_value('Header:value'),
-            self.key_value('Unset-Header:'),
-            self.key_value('Empty-Header;'),
-            self.key_value('list:=["a", 1, {}, false]'),
-            self.key_value('obj:={"a": "b"}'),
-            self.key_value('ed='),
-            self.key_value('bool:=true'),
-            self.key_value('file@' + FILE_PATH_ARG),
-            self.key_value('query==value'),
-            self.key_value('string-embed=@' + FILE_PATH_ARG),
-            self.key_value('raw-json-embed:=@' + JSON_FILE_PATH_ARG),
+        items = RequestItems.from_args([
+            self.key_value_arg('string=value'),
+            self.key_value_arg('Header:value'),
+            self.key_value_arg('Unset-Header:'),
+            self.key_value_arg('Empty-Header;'),
+            self.key_value_arg('list:=["a", 1, {}, false]'),
+            self.key_value_arg('obj:={"a": "b"}'),
+            self.key_value_arg('ed='),
+            self.key_value_arg('bool:=true'),
+            self.key_value_arg('file@' + FILE_PATH_ARG),
+            self.key_value_arg('query==value'),
+            self.key_value_arg('string-embed=@' + FILE_PATH_ARG),
+            self.key_value_arg('raw-json-embed:=@' + JSON_FILE_PATH_ARG),
         ])
 
         # Parsed headers
@@ -99,12 +104,16 @@ class TestItemParsing:
             "string": "value",
             "bool": True,
             "list": ["a", 1, {}, False],
-            "obj": {"a": "b"},
+            "obj": {
+                "a": "b"
+            },
             "string-embed": FILE_CONTENT,
         }
 
         # Parsed query string parameters
-        assert items.params == {'query': 'value'}
+        assert items.params == {
+            'query': 'value'
+        }
 
         # Parsed file fields
         assert 'file' in items.files
@@ -112,17 +121,19 @@ class TestItemParsing:
                 decode('utf8') == FILE_CONTENT)
 
     def test_multiple_file_fields_with_same_field_name(self):
-        items = input.parse_items([
-            self.key_value('file_field@' + FILE_PATH_ARG),
-            self.key_value('file_field@' + FILE_PATH_ARG),
+        items = RequestItems.from_args([
+            self.key_value_arg('file_field@' + FILE_PATH_ARG),
+            self.key_value_arg('file_field@' + FILE_PATH_ARG),
         ])
         assert len(items.files['file_field']) == 2
 
     def test_multiple_text_fields_with_same_field_name(self):
-        items = input.parse_items(
-            [self.key_value('text_field=a'),
-             self.key_value('text_field=b')],
-            data_class=DataDict
+        items = RequestItems.from_args(
+            request_item_args=[
+                self.key_value_arg('text_field=a'),
+                self.key_value_arg('text_field=b')
+            ],
+            as_form=True,
         )
         assert items.data['text_field'] == ['a', 'b']
         assert list(items.data.items()) == [
@@ -206,92 +217,80 @@ class TestLocalhostShorthand:
 class TestArgumentParser:
 
     def setup_method(self, method):
-        self.parser = input.HTTPieArgumentParser()
+        self.parser = httpie.cli.argparser.HTTPieArgumentParser()
 
     def test_guess_when_method_set_and_valid(self):
         self.parser.args = argparse.Namespace()
         self.parser.args.method = 'GET'
         self.parser.args.url = 'http://example.com/'
-        self.parser.args.items = []
+        self.parser.args.request_items = []
         self.parser.args.ignore_stdin = False
-
         self.parser.env = MockEnvironment()
-
         self.parser._guess_method()
-
         assert self.parser.args.method == 'GET'
         assert self.parser.args.url == 'http://example.com/'
-        assert self.parser.args.items == []
+        assert self.parser.args.request_items == []
 
     def test_guess_when_method_not_set(self):
         self.parser.args = argparse.Namespace()
         self.parser.args.method = None
         self.parser.args.url = 'http://example.com/'
-        self.parser.args.items = []
+        self.parser.args.request_items = []
         self.parser.args.ignore_stdin = False
         self.parser.env = MockEnvironment()
-
         self.parser._guess_method()
-
         assert self.parser.args.method == 'GET'
         assert self.parser.args.url == 'http://example.com/'
-        assert self.parser.args.items == []
+        assert self.parser.args.request_items == []
 
     def test_guess_when_method_set_but_invalid_and_data_field(self):
         self.parser.args = argparse.Namespace()
         self.parser.args.method = 'http://example.com/'
         self.parser.args.url = 'data=field'
-        self.parser.args.items = []
+        self.parser.args.request_items = []
         self.parser.args.ignore_stdin = False
         self.parser.env = MockEnvironment()
         self.parser._guess_method()
-
         assert self.parser.args.method == 'POST'
         assert self.parser.args.url == 'http://example.com/'
-        assert self.parser.args.items == [
-            KeyValue(key='data',
-                     value='field',
-                     sep='=',
-                     orig='data=field')
+        assert self.parser.args.request_items == [
+            KeyValueArg(key='data',
+                        value='field',
+                        sep='=',
+                        orig='data=field')
         ]
 
     def test_guess_when_method_set_but_invalid_and_header_field(self):
         self.parser.args = argparse.Namespace()
         self.parser.args.method = 'http://example.com/'
         self.parser.args.url = 'test:header'
-        self.parser.args.items = []
+        self.parser.args.request_items = []
         self.parser.args.ignore_stdin = False
-
         self.parser.env = MockEnvironment()
-
         self.parser._guess_method()
-
         assert self.parser.args.method == 'GET'
         assert self.parser.args.url == 'http://example.com/'
-        assert self.parser.args.items, [
-            KeyValue(key='test',
-                     value='header',
-                     sep=':',
-                     orig='test:header')
+        assert self.parser.args.request_items, [
+            KeyValueArg(key='test',
+                        value='header',
+                        sep=':',
+                        orig='test:header')
         ]
 
     def test_guess_when_method_set_but_invalid_and_item_exists(self):
         self.parser.args = argparse.Namespace()
         self.parser.args.method = 'http://example.com/'
         self.parser.args.url = 'new_item=a'
-        self.parser.args.items = [
-            KeyValue(
+        self.parser.args.request_items = [
+            KeyValueArg(
                 key='old_item', value='b', sep='=', orig='old_item=b')
         ]
         self.parser.args.ignore_stdin = False
-
         self.parser.env = MockEnvironment()
-
         self.parser._guess_method()
-
-        assert self.parser.args.items, [
-            KeyValue(key='new_item', value='a', sep='=', orig='new_item=a'),
-            KeyValue(
+        assert self.parser.args.request_items, [
+            KeyValueArg(key='new_item', value='a', sep='=', orig='new_item=a'),
+            KeyValueArg(
                 key='old_item', value='b', sep='=', orig='old_item=b'),
         ]
 

tests/test_exit_status.py

@@ -5,7 +5,7 @@ from utils import MockEnvironment, http, HTTP_OK
 
 
 def test_keyboard_interrupt_during_arg_parsing_exit_status(httpbin):
-    with mock.patch('httpie.cli.parser.parse_args',
+    with mock.patch('httpie.cli.definition.parser.parse_args',
                     side_effect=KeyboardInterrupt()):
         r = http('GET', httpbin.url + '/get', error_exit_ok=True)
         assert r.exit_status == ExitStatus.ERROR_CTRL_C

tests/test_httpie.py

@@ -1,7 +1,7 @@
 """High-level tests."""
 import pytest
 
-from httpie.input import ParseError
+from httpie.cli.exceptions import ParseError
 from utils import MockEnvironment, http, HTTP_OK
 from fixtures import FILE_PATH, FILE_CONTENT
 

tests/test_sessions.py

@@ -140,10 +140,6 @@ class TestSession(SessionTestBase):
         assert HTTP_OK in r2
         assert r2.json['headers']['Foo'] == 'Bar'
 
-    @pytest.mark.skipif(
-        sys.version_info >= (3,),
-        reason="This test fails intermittently on Python 3 - "
-               "see https://github.com/jakubroztocil/httpie/issues/282")
     def test_session_unicode(self, httpbin):
         self.start_session(httpbin)
 

tests/test_ssl.py

@@ -5,7 +5,7 @@ import pytest_httpbin.certs
 import requests.exceptions
 
 from httpie import ExitStatus
-from httpie.input import SSL_VERSION_ARG_MAPPING
+from httpie.cli.constants import SSL_VERSION_ARG_MAPPING
 from utils import HTTP_OK, TESTS_ROOT, http
 
 

tests/test_uploads.py

@@ -2,7 +2,7 @@ import os
 
 import pytest
 
-from httpie.input import ParseError
+from httpie.cli.exceptions import ParseError
 from utils import MockEnvironment, http, HTTP_OK
 from fixtures import FILE_PATH_ARG, FILE_PATH, FILE_CONTENT