Пример #1
0
 def test_require_one_returns_data_with_data_removed(self):
     data = {"a": 0, "b": 1, "c": "abc"}
     req = require_if("a", Mock(return_value=False))
     val = req(data)
     self.assertEqual(val, {"b": 1, "c": "abc"})
     data = {"a": 0, "b": 1, "c": "abc"}
     req = require_if("a", Mock(return_value=True))
     val = req(data)
     self.assertEqual(val, {"a": 0, "b": 1, "c": "abc"})
 def test_require_one_returns_data_with_data_removed(self):
     data = {"a": 0, "b": 1, "c": "abc"}
     req = require_if("a", Mock(return_value=False))
     val = req(data)
     self.assertEqual(val, {"b": 1, "c": "abc"})
     data = {"a": 0, "b": 1, "c": "abc"}
     req = require_if("a", Mock(return_value=True))
     val = req(data)
     self.assertEqual(val, {"a": 0, "b": 1, "c": "abc"})
 def test_require_if_returns_an_invalid_group_with_invalids_removed(self):
     data = {"a": Invalid("a"), "b": 1, "c": Invalid("c"), "d": 2}
     req = require_if("a", Mock(return_value=False))
     with self.assertRaises(InvalidGroup) as cm:
         req(InvalidGroup("", [data["a"], data["c"]], data))
     self.assertEqual(str(cm.exception), "c")
     self.assertEqual(cm.exception.data, {"b": 1, "c": data["c"], "d": 2})
     data = {"a": Invalid("a"), "b": 1, "c": Invalid("c"), "d": 2}
     req = require_if("a", Mock(return_value=True))
     with self.assertRaises(InvalidGroup) as cm:
         req(InvalidGroup("", [data["a"], data["c"]], data))
     self.assertEqual(str(cm.exception), "a\nc")
     self.assertEqual(
         cm.exception.data,
         {"a": data["a"], "b": 1, "c": data["c"], "d": 2})
    def test_more_advanced_integration_test(self):
        def percents_add_to_100(data):
            total = 0
            for project in data:
                total += project["percentage"]
            if total != 100:
                raise Invalid("the percentages must add up to 100")
            return data

        def check_required_by(data):
            return "required_by_type" in data and data["required_by_type"] == "later"
        s = Schema(
            Chain(
                {
                    "description": All(str, when_empty(Invalid)),
                    "justification": All(str, when_empty(Invalid)),
                    "is_tech_purchase": All(bool, when_empty(False)),
                    "projects": All(
                        [{
                            "id": All(int, when_empty(Undefined)),
                            "project_id": All(int, when_empty(Invalid)),
                            "percentage": All(
                                int, in_range(1, 100), when_empty(Invalid))
                        }],
                        percents_add_to_100
                    ),
                    "vendor": All(str, when_empty(Invalid)),
                    "vendor_id": All(int, when_empty(Invalid)),
                    "required_by_type": All(str, in_list(["now", "later"])),
                    "date_required_by": All(int, when_empty(Invalid))
                },
                require_one("vendor_id", "vendor"),
                require_if("date_required_by", check_required_by)))
        data = {
            "description": "abc",
            "justification": "def",
            "projects": [
                {"project_id": 4, "percentage": 10},
                {"id": 2, "project_id": 5, "percentage": 90}
            ],
            "vendor": "ABC co.",
            "required_by_type": "later",
            "date_required_by": 1234
        }
        val = s(data)
        self.assertEqual(
            val, {
                "description": "abc",
                "justification": "def",
                "is_tech_purchase": False,
                "projects": [
                    {"project_id": 4, "percentage": 10},
                    {"id": 2, "project_id": 5, "percentage": 90}
                ],
                "vendor": "ABC co.",
                "required_by_type": "later",
                "date_required_by": 1234
            })
Пример #5
0
 def test_require_if_returns_an_invalid_group_with_invalids_removed(self):
     data = {"a": Invalid("a"), "b": 1, "c": Invalid("c"), "d": 2}
     req = require_if("a", Mock(return_value=False))
     with self.assertRaises(InvalidGroup) as cm:
         req(InvalidGroup("", [data["a"], data["c"]], data))
     self.assertEqual(str(cm.exception), "c")
     self.assertEqual(cm.exception.data, {"b": 1, "c": data["c"], "d": 2})
     data = {"a": Invalid("a"), "b": 1, "c": Invalid("c"), "d": 2}
     req = require_if("a", Mock(return_value=True))
     with self.assertRaises(InvalidGroup) as cm:
         req(InvalidGroup("", [data["a"], data["c"]], data))
     self.assertEqual(str(cm.exception), "a\nc")
     self.assertEqual(cm.exception.data, {
         "a": data["a"],
         "b": 1,
         "c": data["c"],
         "d": 2
     })
 def test_require_one_returns_data_with_invalids_removed(self):
     data = {"a": Invalid("a"), "b": 1, "c": "abc", "d": 2}
     req = require_if("a", Mock(return_value=False))
     val = req(InvalidGroup("", [data["a"]], data))
     self.assertEqual(val, {"b": 1, "c": "abc", "d": 2})
Пример #7
0
    def test_more_advanced_integration_test(self):
        def percents_add_to_100(data):
            total = 0
            for project in data:
                total += project["percentage"]
            if total != 100:
                raise Invalid("the percentages must add up to 100")
            return data

        def check_required_by(data):
            return "required_by_type" in data and data[
                "required_by_type"] == "later"

        s = Schema(
            Chain(
                {
                    "description":
                    All(str, when_empty(Invalid)),
                    "justification":
                    All(str, when_empty(Invalid)),
                    "is_tech_purchase":
                    All(bool, when_empty(False)),
                    "projects":
                    All([{
                        "id":
                        All(int, when_empty(Undefined)),
                        "project_id":
                        All(int, when_empty(Invalid)),
                        "percentage":
                        All(int, in_range(1, 100), when_empty(Invalid))
                    }], percents_add_to_100),
                    "vendor":
                    All(str, when_empty(Invalid)),
                    "vendor_id":
                    All(int, when_empty(Invalid)),
                    "required_by_type":
                    All(str, in_list(["now", "later"])),
                    "date_required_by":
                    All(int, when_empty(Invalid))
                }, require_one("vendor_id", "vendor"),
                require_if("date_required_by", check_required_by)))
        data = {
            "description":
            "abc",
            "justification":
            "def",
            "projects": [{
                "project_id": 4,
                "percentage": 10
            }, {
                "id": 2,
                "project_id": 5,
                "percentage": 90
            }],
            "vendor":
            "ABC co.",
            "required_by_type":
            "later",
            "date_required_by":
            1234
        }
        val = s(data)
        self.assertEqual(
            val, {
                "description":
                "abc",
                "justification":
                "def",
                "is_tech_purchase":
                False,
                "projects": [{
                    "project_id": 4,
                    "percentage": 10
                }, {
                    "id": 2,
                    "project_id": 5,
                    "percentage": 90
                }],
                "vendor":
                "ABC co.",
                "required_by_type":
                "later",
                "date_required_by":
                1234
            })
Пример #8
0
 def test_require_one_returns_data_with_invalids_removed(self):
     data = {"a": Invalid("a"), "b": 1, "c": "abc", "d": 2}
     req = require_if("a", Mock(return_value=False))
     val = req(InvalidGroup("", [data["a"]], data))
     self.assertEqual(val, {"b": 1, "c": "abc", "d": 2})