Fix AssertionError when METHOD appears before options

Fixes #1614

When the HTTP method (POST, GET, etc.) was specified before optional
arguments like --auth-type, argparse's nargs=OPTIONAL behavior caused
incorrect argument parsing, resulting in an AssertionError.

Example failing command:
  http POST --auth-type bearer --auth TOKEN https://example.org

Argparse incorrectly parsed this as:
  - method=None
  - url='POST'
  - URL and request items ended up in unparsed arguments

This commit adds a new _fix_argument_order() method that:
1. Detects when arguments were misparsed
2. Correctly reassigns method, url, and request_items
3. Validates all request items atomically before adding them
4. Properly initializes request_items if None

The fix runs before _apply_no_options() to prevent errors from
unrecognized arguments and maintains backward compatibility with
existing usage patterns.

Tests added:
- test_fix_argument_order_method_before_options
- test_fix_argument_order_method_before_options_with_items
- test_bearer_auth_method_before_options

Author: ns-fboucault

httpie/cli/argparser.py

@@ -166,6 +166,8 @@ def parse_args(
         )
         self.has_input_data = self.has_stdin_data or self.args.raw is not None
         # Arguments processing and environment setup.
+        # Fix argument misparsing before processing no_options
+        no_options = self._fix_argument_order(no_options)
         self._apply_no_options(no_options)
         self._process_request_type()
         self._process_download_options()
@@ -193,6 +195,54 @@ def parse_args(
 
         return self.args
 
+    def _fix_argument_order(self, no_options):
+        """Fix argument parsing issues caused by argparse's nargs=OPTIONAL
+        not working well with intermixed arguments.
+        
+        When METHOD is specified before options (e.g., POST --auth-type bearer URL),
+        argparse may incorrectly parse:
+          - method=None, url=POST, and URL+items end up in no_options
+        
+        This method detects and fixes such cases.
+        """
+        if (
+            self.args.method is None
+            and self.args.url
+            and re.match('^[a-zA-Z]+$', self.args.url)
+            and no_options
+            and len(no_options) >= 1
+            and not no_options[0].startswith('-')
+        ):
+            # Likely case: method was not parsed, URL is in method position,
+            # and actual URL (and possibly request items) are in no_options
+            self.args.method = self.args.url.upper()
+            self.args.url = no_options[0]
+            
+            # Any remaining items in no_options should be request items
+            # We need to parse them as KeyValue args and add to request_items
+            remaining = no_options[1:]
+            if remaining:
+                # Bug fix: Validate all items before adding any (atomicity)
+                parsed_items = []
+                for item_str in remaining:
+                    try:
+                        parsed_item = KeyValueArgType(
+                            *SEPARATOR_GROUP_ALL_ITEMS).__call__(item_str)
+                        parsed_items.append(parsed_item)
+                    except argparse.ArgumentTypeError:
+                        # If any item fails to parse, return it as an unrecognized arg
+                        # so _apply_no_options will handle the error
+                        return [item_str]
+                
+                # Bug fix: Initialize request_items if it's None
+                if self.args.request_items is None:
+                    self.args.request_items = []
+                
+                # All items parsed successfully, add them to request_items
+                self.args.request_items.extend(parsed_items)
+            return []
+        return no_options
+
     def _process_request_type(self):
         request_type = self.args.request_type
         self.args.json = request_type is RequestType.JSON

tests/test_auth.py

@@ -38,6 +38,17 @@ def test_bearer_auth(httpbin_both, token):
     assert r.json == {'authenticated': True, 'token': token}
 
 
+def test_bearer_auth_method_before_options(httpbin_both):
+    """Test fix for bug #1614: METHOD before --auth-type works correctly."""
+    # This used to raise AssertionError due to incorrect argument parsing
+    # when the METHOD appeared before the auth options
+    r = http('GET', '--auth-type', 'bearer', '--auth', 'test-token',
+             httpbin_both + '/bearer')
+
+    assert HTTP_OK in r
+    assert r.json == {'authenticated': True, 'token': 'test-token'}
+
+
 @mock.patch('httpie.cli.argtypes.AuthCredentials._getpass',
             new=lambda self, prompt: 'password')
 def test_password_prompt(httpbin):

tests/test_cli.py

@@ -316,6 +316,45 @@ def test_guess_when_method_set_but_invalid_and_item_exists(self):
                 key='old_item', value='b', sep='=', orig='old_item=b'),
         ]
 
+    def test_fix_argument_order_method_before_options(self):
+        """Test fix for bug #1614: METHOD before options causes misparsing."""
+        # Simulate: http POST --auth-type bearer https://example.org
+        # Argparse incorrectly parses as: method=None, url='POST', no_options=['https://example.org']
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = None
+        self.parser.args.url = 'POST'
+        self.parser.args.request_items = []
+        no_options = ['https://example.org']
+        
+        # Call _fix_argument_order to correct the misparsing
+        result = self.parser._fix_argument_order(no_options)
+        
+        # Verify the arguments were fixed
+        assert self.parser.args.method == 'POST'
+        assert self.parser.args.url == 'https://example.org'
+        assert result == []
+
+    def test_fix_argument_order_method_before_options_with_items(self):
+        """Test fix for bug #1614 with request items."""
+        # Simulate: http POST --auth-type bearer https://example.org foo=bar
+        # Argparse incorrectly parses as: method=None, url='POST', no_options=['https://example.org', 'foo=bar']
+        self.parser.args = argparse.Namespace()
+        self.parser.args.method = None
+        self.parser.args.url = 'POST'
+        self.parser.args.request_items = []
+        no_options = ['https://example.org', 'foo=bar']
+        
+        # Call _fix_argument_order to correct the misparsing
+        result = self.parser._fix_argument_order(no_options)
+        
+        # Verify the arguments were fixed
+        assert self.parser.args.method == 'POST'
+        assert self.parser.args.url == 'https://example.org'
+        assert len(self.parser.args.request_items) == 1
+        assert self.parser.args.request_items[0].key == 'foo'
+        assert self.parser.args.request_items[0].value == 'bar'
+        assert result == []
+
 
 class TestNoOptions: