--- a/tests/test_urltree.py	Mon Feb 16 20:07:45 2009 +0200
+++ b/tests/test_urltree.py	Mon Feb 16 20:56:05 2009 +0200
@@ -60,6 +60,9 @@
     def test_parse_value_type_int (self) :
         self._test_parse("{foo:int}", urltree.SimpleValueLabel, key="foo", type_name="int", type=urltree.URLConfig.BUILTIN_TYPES['int'])
     
+    def test_parse_invalid_type (self) :
+        self.assertRaises(KeyError, self._test_parse, "{foo:bar}", None)
+
 class TestEmptyLabel (unittest.TestCase) :
     def setUp (self) :
         self.label = urltree.EmptyLabel()
@@ -252,6 +255,9 @@
 
     def test_get_type (self) :
         self.assertEquals(urltree.URLConfig(dict(foo='xxx')).get_type('foo'), 'xxx')
+    
+    def test_get_type_invalid (self) :
+        self.assertRaises(KeyError, urltree.URLConfig(dict(foo='xxx')).get_type, 'xxx')
 
     def test_call (self) :
         config = urltree.URLConfig()
@@ -270,3 +276,152 @@
         self.assertTrue(urls[0].url_mask == "foo1")
         self.assertTrue(urls[1].url_mask == "foo2")
 
+class TestURL (unittest.TestCase) :
+    def setUp (self) :
+        self.config = urltree.URLConfig(ignore_extra_args=True)
+        self.config_strict = urltree.URLConfig(ignore_extra_args=False)
+    
+    def _test_label_path (self, mask, *path, **qargs) :
+        url = self.config(mask, None)
+        
+        # right label path
+        self.assertEquals(url.label_path, list(path))
+        
+        # right qargs keys
+        self.assertEquals(set(url.query_args), set(qargs))
+        
+        # right qargs values
+        for key, value in qargs.iteritems() :
+            self.assertEquals(url.query_args[key], value)
+
+    def test_label_path_empty (self) :
+        self._test_label_path("", urltree.EmptyLabel())
+    
+    def test_label_path_root (self) :
+        self._test_label_path("/", urltree.EmptyLabel())
+
+    def test_label_path_static (self) :
+        self._test_label_path("/foo", urltree.StaticLabel("foo"))
+
+    def test_label_path_static2 (self) :
+        self._test_label_path("/foo/bar/", urltree.StaticLabel("foo"), urltree.StaticLabel("bar"), urltree.EmptyLabel())
+    
+    def test_label_path_mix (self) :
+        self._test_label_path("/foo/{bar}", urltree.StaticLabel("foo"), urltree.SimpleValueLabel("bar", None, None, None))
+    
+#    def test_query_args_root_empty (self) :
+#        self._test_label_path("/?", urltree.EmptyLabel())
+
+    def test_query_args_simple (self) :
+        self._test_label_path("/x/?foo", urltree.StaticLabel("x"), foo=(self.config.get_type(None), None))
+
+    def test_query_args_multi (self) :
+        self._test_label_path("/x/?foo=0&bar&tee:int=&eee:int", urltree.StaticLabel("x"), 
+            foo = (self.config.get_type(None), "0"),
+            bar = (self.config.get_type(None), None),
+            tee = (self.config.get_type('int'), ''),
+            eee = (self.config.get_type('int'), None),
+        )
+    
+    def test_label_path_mutate (self) :
+        l = self.config("xxx", None)
+
+        lp = l.get_label_path()
+
+        lp.pop(0)
+
+        self.assertTrue(len(l.label_path) > len(lp))
+    
+    def _setup_handler (self) :
+        def _handler (req, **kwargs) :
+            return kwargs
+
+        return _handler
+    
+    def _setup_execute (self, mask, config) :
+        _handler = self._setup_handler()
+
+        url = config(mask, _handler)
+
+        return url
+    
+    class dummyrequest :
+        def __init__ (self, qargs) : self.qargs = qargs
+        def get_args (self) : return self.qargs
+    
+    class dummy_label :
+        def __init__ (self, key, type) :
+            self.key = key
+            self.type = type
+
+    class dummy_labelvalue :
+        def __init__ (self, key, value, is_default, type) : 
+            self.label = TestURL.dummy_label(key, type)
+            self.value = value
+            self.is_default = is_default
+
+    def _test_execute (self, mask, values={}, qargs={}, qlist=[], config=None) :
+        if not config :
+            config = self.config
+
+        # setup
+        url = self._setup_execute(mask, config)
+        req = self.dummyrequest(qargs.items() + qlist)
+        values = [self.dummy_labelvalue(k, v, d, config.get_type()) for k, (v, d) in values.iteritems()]
+
+        # exec
+        out_args = url.execute(req, values)
+        
+        return out_args
+        
+    def test_execute_empty (self) :
+        self.assertEquals(set(self._test_execute("/")), set())
+
+    def test_execute_plain (self) :
+        self.assertEquals(set(self._test_execute("/foo")), set())
+
+    def test_execute_simple (self) :
+        self.assertEquals(self._test_execute("/foo/{bar}", dict(bar=(0, False))), dict(bar=0))
+
+    def test_execute_multi (self) :
+        self.assertEquals(self._test_execute("/foo/{bar}/{quux}", dict(bar=(1, False), quux=(2, False))), dict(bar=1, quux=2))
+
+    def test_execute_default (self) :
+        self.assertEquals(self._test_execute("/foo/{bar=0}", dict(bar=("0", True))), dict(bar="0"))
+    
+    def test_execute_qargs_default (self) :
+        self.assertEquals(self._test_execute("/{foo}/?bar=0", dict(foo=("x", False))), dict(foo="x", bar="0"))
+    
+    def test_execute_qargs_default_type (self) :
+        self.assertEquals(self._test_execute("/{foo}/?bar:int=0", dict(foo=("x", False))), dict(foo="x", bar=0))
+
+    def test_execute_qargs_default_none (self) :
+        self.assertEquals(self._test_execute("/{foo}/?bar=", dict(foo=("x", False))), dict(foo="x"))
+
+    def test_execute_qargs_missing (self) :
+        self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False)))
+
+    def test_execute_qargs_invalid (self) :
+        self.assertRaises(ValueError, self._test_execute, "/{foo}/?bar:int", dict(foo=("x", False)), dict(bar="x"))
+
+    def test_execute_qargs_simple (self) :
+        self.assertEquals(self._test_execute("/{foo}/?bar", dict(foo=("x", False)), dict(bar="y")), dict(foo="x", bar="y"))
+
+    def test_execute_qargs_novalue (self) :
+        self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False)), dict(bar=''))
+
+    def test_execute_qargs_multi_invalid (self) :
+        self.assertRaises(urltree.URLError, self._test_execute, "/{foo}/?bar", dict(foo=("x", False)), qlist=[('bar', 'a'), ('bar', 'b')])
+
+    def test_execute_qargs_multi_list (self) :
+        self.assertEqual(self._test_execute("/{foo}/?bar:list", dict(foo=("x", False)), qlist=[('bar', 'a'), ('bar', 'b')]), dict(foo='x', bar=['a', 'b']))
+
+    def test_execute_qarg_override_strict (self) :
+        self.assertRaises(urltree.URLError, self._test_execute, "/{foo}", dict(foo=("x1", False)), dict(foo="x2"), config=self.config_strict)
+
+    def test_execute_qarg_override_ignore (self) :
+        self.assertEqual(self._test_execute("/{foo}", dict(foo=("x1", False)), dict(foo="x2")), dict(foo="x1"))
+        
+    def test_execute_qarg_override_ok (self) :
+        self.assertEqual(self._test_execute("/{foo=x1}", dict(foo=("x1", True)), dict(foo="x2")), dict(foo="x2"))
+

--- a/urltree.py	Mon Feb 16 20:07:45 2009 +0200
+++ b/urltree.py	Mon Feb 16 20:56:05 2009 +0200
@@ -615,18 +615,21 @@
             else :
                 # parse value
                 value = type.parse(value)
-
+            
+            # XXX: this should set it to True or something... it's a flag, "/foo?bar"
             # set default?
             if value is None :
-                if default :
-                    value = default
-
                 if default == '' :
                     # do not pass key at all
                     continue
 
-                # otherwise, fail
-                raise URLError("No value given for required argument: %r" % (key, ))
+                elif default is not None :
+                    # pass default value
+                    value = default
+
+                else :
+                    # required arg, no default
+                    raise URLError("No value given for required argument: %r" % (key, ))
             
             # already have a non-default value?
             if key in kwargs and key not in default_labels :