← Back to branch summary

~tribaal/txaws/xss-hardening

« back to all changes in this revision

Viewing changes to txaws/server/tests/test_schema.py

Merged 921421-completemultipart [r=oubiwann][f=921421]

This branch adds Complete Multipart method to s3 client.

Show diffs side-by-side

added added

removed removed

Lines of Context:
txaws/server/tests/test_schema.py
9
9
from txaws.server.exception import APIError
10
10
from txaws.server.schema import (
11
11
    Arguments, Bool, Date, Enum, Integer, Parameter, RawStr, Schema, Unicode,
12
 
    UnicodeLine, List, Structure, InconsistentParameterError)
 
12
    List, Structure,
 
13
    InconsistentParameterError)
13
14
 
14
15
 
15
16
class ArgumentsTestCase(TestCase):
41
42
        arguments = Arguments({})
42
43
        self.assertRaises(KeyError, arguments.__getitem__, 1)
43
44
 
44
 
    def test_contains(self):
45
 
        """
46
 
        The presence of a certain argument can be inspected using the 'in'
47
 
        keyword.
48
 
        ."""
49
 
        arguments = Arguments({"foo": 1})
50
 
        self.assertIn("foo", arguments)
51
 
        self.assertNotIn("bar", arguments)
52
 
 
53
45
    def test_len(self):
54
46
        """C{len()} can be used with an L{Arguments} instance."""
55
47
        self.assertEqual(0, len(Arguments({})))
211
203
            Enum(mapping={"hey": 1}, doc="foo"),
212
204
            Date(doc="foo"),
213
205
            List(item=Integer(), doc="foo"),
214
 
            Structure(fields={}, doc="foo")]
 
206
            Structure(fields={}, doc="foo")
 
207
            ]
215
208
        for parameter in parameters:
216
209
            self.assertEqual("foo", parameter.doc)
217
210
 
260
253
        self.assertEqual("InvalidParameterValue", error.code)
261
254
 
262
255
 
263
 
class UnicodeLineTestCase(TestCase):
264
 
 
265
 
    def test_parse(self):
266
 
        """L{UnicodeLine.parse} converts the given raw C{value} to
267
 
        C{unicode}."""
268
 
        parameter = UnicodeLine("Test")
269
 
        self.assertEqual(u"foo", parameter.parse("foo"))
270
 
 
271
 
    def test_newlines_in_text(self):
272
 
        """
273
 
        The L{UnicodeLine} parameter returns an error if text contains
274
 
        newlines.
275
 
        """
276
 
        parameter = UnicodeLine("Test")
277
 
        error = self.assertRaises(APIError, parameter.coerce, "Test\nError")
278
 
        self.assertIn(u"Can't contain newlines", error.message)
279
 
        self.assertEqual(400, error.status)
280
 
 
281
 
 
282
256
class RawStrTestCase(TestCase):
283
257
 
284
258
    def test_parse(self):
410
384
 
411
385
class SchemaTestCase(TestCase):
412
386
 
413
 
    def test_get_parameters(self):
414
 
        """
415
 
        L{Schema.get_parameters} returns the original list of parameters.
416
 
        """
417
 
        schema = Schema(parameters=[
418
 
            Unicode("name"),
419
 
            List("scores", Integer())])
420
 
        parameters = schema.get_parameters()
421
 
        self.assertEqual("name", parameters[0].name)
422
 
        self.assertEqual("scores", parameters[1].name)
423
 
 
424
 
    def test_get_parameters_order_on_parameter_only_construction(self):
425
 
        """
426
 
        L{Schema.get_parameters} returns the original list of L{Parameter}s
427
 
        even when they are passed as positional arguments to L{Schema}.
428
 
        """
429
 
        schema = Schema(
430
 
            Unicode("name"),
431
 
            List("scores", Integer()),
432
 
            Integer("index", Integer()))
433
 
        self.assertEqual(["name", "scores", "index"],
434
 
                         [p.name for p in schema.get_parameters()])
435
 
 
436
387
    def test_extract(self):
437
388
        """
438
389
        L{Schema.extract} returns an L{Argument} object whose attributes are
564
515
        given without an index.
565
516
        """
566
517
        schema = Schema(Unicode("name.n"))
567
 
        self.assertRaises(
568
 
            InconsistentParameterError,
569
 
            schema.extract, {"nameFOOO": "foo", "nameFOOO.1": "bar"})
 
518
        self.assertRaises(InconsistentParameterError,
 
519
                          schema.extract, {"name": "foo", "name.1": "bar"})
570
520
 
571
521
    def test_extract_with_non_numbered_template(self):
572
522
        """
664
614
    def test_bundle_with_structure(self):
665
615
        """L{Schema.bundle} can bundle L{Structure}s."""
666
616
        schema = Schema(
667
 
            parameters=[
668
 
                Structure("struct", fields={"field1": Unicode(),
669
 
                                            "field2": Integer()})])
 
617
            parameters={
 
618
                "struct": Structure(fields={"field1": Unicode(),
 
619
                                            "field2": Integer()})})
670
620
        params = schema.bundle(struct={"field1": "hi", "field2": 59})
671
621
        self.assertEqual({"struct.field1": "hi", "struct.field2": "59"},
672
622
                         params)
673
623
 
674
624
    def test_bundle_with_list(self):
675
625
        """L{Schema.bundle} can bundle L{List}s."""
676
 
        schema = Schema(parameters=[List("things", item=Unicode())])
 
626
        schema = Schema(parameters={"things": List(item=Unicode())})
677
627
        params = schema.bundle(things=["foo", "bar"])
678
628
        self.assertEqual({"things.1": "foo", "things.2": "bar"}, params)
679
629
 
682
632
        L{Schema.bundle} can bundle L{Structure}s (specified as L{Arguments}).
683
633
        """
684
634
        schema = Schema(
685
 
            parameters=[
686
 
                Structure("struct", fields={"field1": Unicode(),
687
 
                                            "field2": Integer()})])
 
635
            parameters={
 
636
                "struct": Structure(fields={"field1": Unicode(),
 
637
                                            "field2": Integer()})})
688
638
        params = schema.bundle(struct=Arguments({"field1": "hi",
689
639
                                                 "field2": 59}))
690
640
        self.assertEqual({"struct.field1": "hi", "struct.field2": "59"},
692
642
 
693
643
    def test_bundle_with_list_with_arguments(self):
694
644
        """L{Schema.bundle} can bundle L{List}s (specified as L{Arguments})."""
695
 
        schema = Schema(parameters=[List("things", item=Unicode())])
 
645
        schema = Schema(parameters={"things": List(item=Unicode())})
696
646
        params = schema.bundle(things=Arguments({1: "foo", 2: "bar"}))
697
647
        self.assertEqual({"things.1": "foo", "things.2": "bar"}, params)
698
648
 
820
770
        {name: field} format.
821
771
        """
822
772
        schema = Schema(
823
 
            parameters=[Structure("foo",
824
 
                                  fields={"l": List(item=Integer())})])
 
773
            parameters={"foo": Structure(
 
774
                    fields={"l": List(item=Integer())})})
825
775
        arguments, _ = schema.extract({"foo.l.1": "1", "foo.l.2": "2"})
826
776
        self.assertEqual([1, 2], arguments.foo.l)
827
777
 
828
 
    def test_schema_conversion_list(self):
 
778
    def test_schema_conversion_list_name(self):
829
779
        """
830
780
        Backwards-compatibility conversion maintains the name of lists.
831
781
        """
832
782
        schema = Schema(Unicode("foos.N"))
833
 
        parameters = schema.get_parameters()
834
 
        self.assertEqual(1, len(parameters))
835
 
        self.assertTrue(isinstance(parameters[0], List))
836
 
        self.assertEqual("foos", parameters[0].name)
837
 
 
838
 
    def test_coerce_list(self):
839
 
        """
840
 
        When a L{List} coerces the value of one of its item, it uses the the
841
 
        proper name in the C{MissingParameter} error raised.
842
 
        """
843
 
        parameter = List("foo", Unicode())
844
 
        error = self.assertRaises(APIError, parameter.item.coerce, "")
845
 
        self.assertEqual(400, error.status)
846
 
        self.assertEqual("MissingParameter", error.code)
847
 
        self.assertEqual("The request must contain the parameter foo "
848
 
                         "(unicode)",
849
 
                         error.message)
 
783
        self.assertEqual("foos", schema._parameters["foos"].name)
850
784
 
851
785
    def test_schema_conversion_structure_name(self):
852
786
        """
855
789
        """
856
790
        schema = Schema(Unicode("foos.N.field"),
857
791
                        Unicode("foos.N.field2"))
858
 
        parameters = schema.get_parameters()
859
 
        self.assertEqual(1, len(parameters))
860
 
        self.assertTrue(isinstance(parameters[0], List))
861
 
        self.assertEqual("foos", parameters[0].name)
862
 
        self.assertEqual("N",
863
 
                         parameters[0].item.name)
864
 
        self.assertEqual("field",
865
 
                         parameters[0].item.fields["field"].name)
866
 
        self.assertEqual("field2",
867
 
                         parameters[0].item.fields["field2"].name)
 
792
        self.assertEqual("anonymous_structure",
 
793
                         schema._parameters["foos"].item.name)
 
794
        self.assertEqual("foos.N.field",
 
795
                         schema._parameters["foos"].item.fields["field"].name)
 
796
        self.assertEqual("foos.N.field2",
 
797
                         schema._parameters["foos"].item.fields["field2"].name)
868
798
 
869
799
    def test_schema_conversion_optional_list(self):
870
800
        """
890
820
        Additional data can be specified on the Schema class for specifying a
891
821
        more rich schema.
892
822
        """
893
 
        result = {'id': Integer(), 'name': Unicode(), 'data': RawStr()}
 
823
        result = {
 
824
                'id': Integer(),
 
825
                'name': Unicode(),
 
826
                'data': RawStr()}
894
827
        errors = [APIError]
895
828
 
896
829
        schema = Schema(
897
830
            name="GetStuff",
898
831
            doc="""Get the stuff.""",
899
 
            parameters=[
900
 
                Integer("id"),
901
 
                Unicode("scope")],
 
832
            parameters={
 
833
                'id': Integer(),
 
834
                'scope': Unicode()},
902
835
            result=result,
903
836
            errors=errors)
904
837
 
911
844
        """
912
845
        The additional schema attributes can be passed to L{Schema.extend}.
913
846
        """
914
 
        result = {'id': Integer(), 'name': Unicode(), 'data': RawStr()}
 
847
        result = {
 
848
                'id': Integer(),
 
849
                'name': Unicode(),
 
850
                'data': RawStr()}
915
851
        errors = [APIError]
916
852
 
917
853
        schema = Schema(
918
854
            name="GetStuff",
919
 
            parameters=[Integer("id")])
 
855
            parameters={"id": Integer()})
920
856
 
921
857
        schema2 = schema.extend(
922
858
            name="GetStuff2",
923
859
            doc="Get stuff 2",
924
 
            parameters=[Unicode("scope")],
 
860
            parameters={'scope': Unicode()},
925
861
            result=result,
926
862
            errors=errors)
927
863
 
939
875
        If additional schema attributes aren't passed to L{Schema.extend}, they
940
876
        stay the same.
941
877
        """
942
 
        result = {'id': Integer(), 'name': Unicode(), 'data': RawStr()}
 
878
        result = {
 
879
                'id': Integer(),
 
880
                'name': Unicode(),
 
881
                'data': RawStr()}
943
882
        errors = [APIError]
944
883
 
945
884
        schema = Schema(
946
885
            name="GetStuff",
947
886
            doc="""Get the stuff.""",
948
 
            parameters=[Integer("id")],
 
887
            parameters={'id': Integer()},
949
888
            result=result,
950
889
            errors=errors)
951
890
 
952
 
        schema2 = schema.extend(parameters=[Unicode("scope")])
 
891
        schema2 = schema.extend(parameters={'scope': Unicode()})
953
892
 
954
893
        self.assertEqual("GetStuff", schema2.name)
955
894
        self.assertEqual("Get the stuff.", schema2.doc)
964
903
        """
965
904
        Result fields can also be extended with L{Schema.extend}.
966
905
        """
967
 
        schema = Schema(result={'name': Unicode()})
 
906
        schema = Schema(
 
907
            result={'name': Unicode()}
 
908
            )
968
909
        schema2 = schema.extend(
969
910
            result={'id': Integer()})
970
911
        result_structure = Structure(fields=schema2.result)
976
917
        """
977
918
        Errors can be extended with L{Schema.extend}.
978
919
        """
979
 
        schema = Schema(parameters=[], errors=[APIError])
 
920
        schema = Schema(parameters={}, errors=[APIError])
980
921
        schema2 = schema.extend(errors=[ZeroDivisionError])
981
922
        self.assertEqual(set([APIError, ZeroDivisionError]), schema2.errors)
982
 
 
983
 
    def test_extend_maintains_parameter_order(self):
984
 
        """
985
 
        Extending a schema with additional parameters puts the new parameters
986
 
        at the end.
987
 
        """
988
 
        schema = Schema(parameters=[Unicode("name"), Unicode("value")])
989
 
        schema2 = schema.extend(parameters=[Integer("foo"), Unicode("index")])
990
 
        self.assertEqual(["name", "value", "foo", "index"],
991
 
                         [p.name for p in schema2.get_parameters()])
992
 
 
993
 
    def test_schema_field_names(self):
994
 
        structure = Structure(fields={"foo": Integer()})
995
 
        self.assertEqual("foo", structure.fields["foo"].name)