Пример #1
0
def test_is_marked_valid_selector_multiple_refs(data):
    """Test that a valid selector returns True if aall marking_refs match.
        Otherwise False."""
    assert markings.is_marked(data, [MARKING_IDS[2], MARKING_IDS[3]], ["labels"])
    assert markings.is_marked(data, [MARKING_IDS[2], MARKING_IDS[1]], ["labels"]) is False
    assert markings.is_marked(data, MARKING_IDS[2], ["labels"])
    assert markings.is_marked(data, ["marking-definition--1234"], ["labels"]) is False
def test_is_marked_valid_selector_no_refs(data):
    """Test that a valid selector return True when it has marking refs and False when not."""
    assert markings.is_marked(data, selectors=["description"])
    assert markings.is_marked(data, [MARKING_IDS[2], MARKING_IDS[3]],
                              ["description"])
    assert markings.is_marked(data, [MARKING_IDS[2]], ["description"])
    assert markings.is_marked(data, [MARKING_IDS[2], MARKING_IDS[5]],
                              ["description"]) is False
Пример #3
0
def test_is_marked_no_markings(data):
    marked = data[0]
    nonmarked = data[1]

    assert markings.is_marked(marked)
    assert markings.is_marked(nonmarked) is False
Пример #4
0
def test_is_marked_object_and_granular_combinations():
    """Test multiple combinations for inherited and descendant markings."""
    test_sdo = \
        {
            "a": 333,
            "b": "value",
            "c": [
                17,
                "list value",
                {
                    "g": "nested",
                    "h": 45
                }
            ],
            "x": {
                "y": [
                    "hello",
                    88
                ],
                "z": {
                    "foo1": "bar",
                    "foo2": 65
                }
            },
            "object_marking_refs": "11",
            "granular_markings": [
                {
                    "marking_ref": "1",
                    "selectors": ["a"]
                },
                {
                    "marking_ref": "2",
                    "selectors": ["c"]
                },
                {
                    "marking_ref": "3",
                    "selectors": ["c.[1]"]
                },
                {
                    "marking_ref": "4",
                    "selectors": ["c.[2]"]
                },
                {
                    "marking_ref": "5",
                    "selectors": ["c.[2].g"]
                },
                {
                    "marking_ref": "6",
                    "selectors": ["x"]
                },
                {
                    "marking_ref": "7",
                    "selectors": ["x.y"]
                },
                {
                    "marking_ref": "8",
                    "selectors": ["x.y.[1]"]
                },
                {
                    "marking_ref": "9",
                    "selectors": ["x.z"]
                },
                {
                    "marking_ref": "10",
                    "selectors": ["x.z.foo2"]
                },
            ]
        }

    assert markings.is_marked(test_sdo, ["1"], "a", False, False)
    assert markings.is_marked(test_sdo, ["1", "11"], "a", True, False)
    assert markings.is_marked(test_sdo, ["1", "11"], "a", True, True)
    assert markings.is_marked(test_sdo, ["1"], "a", False, True)

    assert markings.is_marked(
        test_sdo, "b", inherited=False, descendants=False) is False
    assert markings.is_marked(test_sdo, ["11"], "b", True, False)
    assert markings.is_marked(test_sdo, ["11"], "b", True, True)
    assert markings.is_marked(test_sdo, "b", inherited=False,
                              descendants=True) is False

    assert markings.is_marked(test_sdo, ["2"], "c", False, False)
    assert markings.is_marked(test_sdo, ["2", "11"], "c", True, False)
    assert markings.is_marked(test_sdo, ["2", "3", "4", "5", "11"], "c", True,
                              True)
    assert markings.is_marked(test_sdo, ["2", "3", "4", "5"], "c", False, True)

    assert markings.is_marked(
        test_sdo, "c.[0]", inherited=False, descendants=False) is False
    assert markings.is_marked(test_sdo, ["2", "11"], "c.[0]", True, False)
    assert markings.is_marked(test_sdo, ["2", "11"], "c.[0]", True, True)
    assert markings.is_marked(
        test_sdo, "c.[0]", inherited=False, descendants=True) is False

    assert markings.is_marked(test_sdo, ["3"], "c.[1]", False, False)
    assert markings.is_marked(test_sdo, ["2", "3", "11"], "c.[1]", True, False)
    assert markings.is_marked(test_sdo, ["2", "3", "11"], "c.[1]", True, True)
    assert markings.is_marked(test_sdo, ["3"], "c.[1]", False, True)

    assert markings.is_marked(test_sdo, ["4"], "c.[2]", False, False)
    assert markings.is_marked(test_sdo, ["2", "4", "11"], "c.[2]", True, False)
    assert markings.is_marked(test_sdo, ["2", "4", "5", "11"], "c.[2]", True,
                              True)
    assert markings.is_marked(test_sdo, ["4", "5"], "c.[2]", False, True)

    assert markings.is_marked(test_sdo, ["5"], "c.[2].g", False, False)
    assert markings.is_marked(test_sdo, ["2", "4", "5", "11"], "c.[2].g", True,
                              False)
    assert markings.is_marked(test_sdo, ["2", "4", "5", "11"], "c.[2].g", True,
                              True)
    assert markings.is_marked(test_sdo, ["5"], "c.[2].g", False, True)

    assert markings.is_marked(test_sdo, ["6"], "x", False, False)
    assert markings.is_marked(test_sdo, ["6", "11"], "x", True, False)
    assert markings.is_marked(test_sdo, ["6", "7", "8", "9", "10", "11"], "x",
                              True, True)
    assert markings.is_marked(test_sdo, ["6", "7", "8", "9", "10"], "x", False,
                              True)

    assert markings.is_marked(test_sdo, ["7"], "x.y", False, False)
    assert markings.is_marked(test_sdo, ["6", "7", "11"], "x.y", True, False)
    assert markings.is_marked(test_sdo, ["6", "7", "8", "11"], "x.y", True,
                              True)
    assert markings.is_marked(test_sdo, ["7", "8"], "x.y", False, True)

    assert markings.is_marked(
        test_sdo, "x.y.[0]", inherited=False, descendants=False) is False
    assert markings.is_marked(test_sdo, ["6", "7", "11"], "x.y.[0]", True,
                              False)
    assert markings.is_marked(test_sdo, ["6", "7", "11"], "x.y.[0]", True,
                              True)
    assert markings.is_marked(
        test_sdo, "x.y.[0]", inherited=False, descendants=True) is False

    assert markings.is_marked(test_sdo, ["8"], "x.y.[1]", False, False)
    assert markings.is_marked(test_sdo, ["6", "7", "8", "11"], "x.y.[1]", True,
                              False)
    assert markings.is_marked(test_sdo, ["6", "7", "8", "11"], "x.y.[1]", True,
                              True)
    assert markings.is_marked(test_sdo, ["8"], "x.y.[1]", False, True)

    assert markings.is_marked(test_sdo, ["9"], "x.z", False, False)
    assert markings.is_marked(test_sdo, ["6", "9", "11"], "x.z", True, False)
    assert markings.is_marked(test_sdo, ["6", "9", "10", "11"], "x.z", True,
                              True)
    assert markings.is_marked(test_sdo, ["9", "10"], "x.z", False, True)

    assert markings.is_marked(
        test_sdo, "x.z.foo1", inherited=False, descendants=False) is False
    assert markings.is_marked(test_sdo, ["6", "9", "11"], "x.z.foo1", True,
                              False)
    assert markings.is_marked(test_sdo, ["6", "9", "11"], "x.z.foo1", True,
                              True)
    assert markings.is_marked(
        test_sdo, "x.z.foo1", inherited=False, descendants=True) is False

    assert markings.is_marked(test_sdo, ["10"], "x.z.foo2", False, False)
    assert markings.is_marked(test_sdo, ["6", "9", "10", "11"], "x.z.foo2",
                              True, False)
    assert markings.is_marked(test_sdo, ["6", "9", "10", "11"], "x.z.foo2",
                              True, True)
    assert markings.is_marked(test_sdo, ["10"], "x.z.foo2", False, True)

    assert markings.is_marked(test_sdo, ["11"], None, True, True)
    assert markings.is_marked(test_sdo, ["2"], None, True, True) is False
Пример #5
0
def test_is_marked_no_marking_refs(data):
    """Test that a valid content selector with no marking_refs returns True
        if there is a granular_marking that asserts that field, False
        otherwise."""
    assert markings.is_marked(data, selectors=["type"]) is False
    assert markings.is_marked(data, selectors=["labels"])
Пример #6
0
def test_is_marked_valid_selector_and_refs(data):
    """Test that a valid selector returns True when marking_refs match."""
    assert markings.is_marked(data, [MARKING_IDS[1]], ["description"])
    assert markings.is_marked(data, [MARKING_IDS[1]], ["modified"]) is False
Пример #7
0
def test_is_marked_mix_selector(data):
    """Test valid selector, one marked and one not marked returns True."""
    assert markings.is_marked(data, selectors=["description", "labels"])
    assert markings.is_marked(data, selectors=["description"])
Пример #8
0
def test_is_marked_invalid_selector(data, selector):
    """Test invalid selector raises an error."""
    with pytest.raises(InvalidSelectorError):
        markings.is_marked(data, selectors=selector)
Пример #9
0
def test_is_marked_smoke(data):
    """Smoke test is_marked call does not fail."""
    assert markings.is_marked(data, selectors=["description"])
    assert markings.is_marked(data, selectors=["modified"]) is False
Пример #10
0
def test_clear_marking_all_selectors(data):
    data = markings.clear_markings(data, ["description", "type", "modified"])
    assert markings.is_marked(data, "description") is False
    assert "granular_markings" not in data
Пример #11
0
def test_clear_marking_one_selector(data):
    """Test markings associated with one selector were removed."""
    data = markings.clear_markings(data, "description")
    assert markings.is_marked(data, "description") is False
Пример #12
0
def test_clear_marking_multiple_selectors(data):
    """Test clearing markings for multiple selectors effectively removes associated markings."""
    data = markings.clear_markings(data, ["type", "description"])
    assert markings.is_marked(data, ["type", "description"]) is False
Пример #13
0
def test_clear_marking_smoke(data):
    """Test clear_marking call does not fail."""
    data = markings.clear_markings(data, "modified")
    assert markings.is_marked(data, "modified") is False