summaryrefslogtreecommitdiff
path: root/macaroonbakery/tests/test_time.py
blob: 38826e1218d9c00e234fb7bcf9b27e3ce4252db7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
# Copyright 2017 Canonical Ltd.
# Licensed under the LGPLv3, see LICENCE file for details.
from datetime import timedelta
from unittest import TestCase
from collections import namedtuple

import pyrfc3339
import pymacaroons
from pymacaroons import Macaroon

import macaroonbakery.checkers as checkers

t1 = pyrfc3339.parse('2017-10-26T16:19:47.441402074Z')
t2 = t1 + timedelta(hours=1)
t3 = t2 + timedelta(hours=1)


def fpcaveat(s):
    return pymacaroons.Caveat(caveat_id=s.encode('utf-8'))


class TestExpireTime(TestCase):
    def test_expire_time(self):
        ExpireTest = namedtuple('ExpireTest', 'about caveats expectTime')
        tests = [
            ExpireTest(
                about='no caveats',
                caveats=[],
                expectTime=None,
            ),
            ExpireTest(
                about='single time-before caveat',
                caveats=[
                    fpcaveat(checkers.time_before_caveat(t1).condition),
                ],
                expectTime=t1,
            ),
            ExpireTest(
                about='multiple time-before caveat',
                caveats=[
                    fpcaveat(checkers.time_before_caveat(t2).condition),
                    fpcaveat(checkers.time_before_caveat(t1).condition),
                ],
                expectTime=t1,
            ),
            ExpireTest(
                about='mixed caveats',
                caveats=[
                    fpcaveat(checkers.time_before_caveat(t1).condition),
                    fpcaveat('allow bar'),
                    fpcaveat(checkers.time_before_caveat(t2).condition),
                    fpcaveat('deny foo'),
                ],
                expectTime=t1,
            ),
            ExpireTest(
                about='mixed caveats',
                caveats=[
                    fpcaveat(checkers.COND_TIME_BEFORE + ' tomorrow'),
                ],
                expectTime=None,
            ),
        ]
        for test in tests:
            print('test ', test.about)
            t = checkers.expiry_time(checkers.Namespace(), test.caveats)
            self.assertEqual(t, test.expectTime)

    def test_macaroons_expire_time(self):
        ExpireTest = namedtuple('ExpireTest', 'about macaroons expectTime')
        tests = [
            ExpireTest(
                about='no macaroons',
                macaroons=[newMacaroon()],
                expectTime=None,
            ),
            ExpireTest(
                about='single macaroon without caveats',
                macaroons=[newMacaroon()],
                expectTime=None,
            ),
            ExpireTest(
                about='multiple macaroon without caveats',
                macaroons=[newMacaroon()],
                expectTime=None,
            ),
            ExpireTest(
                about='single macaroon with time-before caveat',
                macaroons=[
                    newMacaroon([checkers.time_before_caveat(t1).condition]),
                ],
                expectTime=t1,
            ),
            ExpireTest(
                about='single macaroon with multiple time-before caveats',
                macaroons=[
                    newMacaroon([
                        checkers.time_before_caveat(t2).condition,
                        checkers.time_before_caveat(t1).condition,
                    ]),
                ],
                expectTime=t1,
            ),
            ExpireTest(
                about='multiple macaroons with multiple time-before caveats',
                macaroons=[
                    newMacaroon([
                        checkers.time_before_caveat(t3).condition,
                        checkers.time_before_caveat(t1).condition,
                    ]),
                    newMacaroon([
                        checkers.time_before_caveat(t3).condition,
                        checkers.time_before_caveat(t1).condition,
                    ]),
                ],
                expectTime=t1,
            ),
        ]
        for test in tests:
            print('test ', test.about)
            t = checkers.macaroons_expiry_time(checkers.Namespace(), test.macaroons)
            self.assertEqual(t, test.expectTime)


def newMacaroon(conds=[]):
    m = Macaroon(key='key', version=2)
    for cond in conds:
        m.add_first_party_caveat(cond)
    return m