rostrum 14.0.1

An efficient implementation of Electrum Server with token support
Documentation 
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
130

# Copyright (c) 2016-2017 The Bitcoin Unlimited developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""
RpcTest class and help functions which create disabled/Skipped tests

>>> sometest=RpcTest("name")
>>> repr(sometest)
'name.py'
>>> sometest.is_disabled()
False
>>> sometest.reason is None
True
>>> sometest.skip_platforms
[]
>>> disabled_test=disabled("foo", "foo does not work right now")
>>> disabled_test.is_disabled()
True
>>> disabled_test.reason
'foo does not work right now'
>>> disabled_test.skip_platforms
[]
>>> skipped_test=skip("bar", "", "bar is skipped on all platforms because all matches empty string")
>>> skipped_test.is_skipped()
True
>>> unskipped_test=skip("baz", "NoSuchPlatform", "baz is not skipped since there is no such platform")
>>> unskipped_test.is_skipped()
False
>>> testwithargs=RpcTest("name --somearg --anotherarg")
>>> repr(testwithargs)
'name.py --somearg --anotherarg'
"""

import platform

# collect as much platform info as we want people to be able to filter
# against for skipped tests
# platform.node() is not included because too easy to get an accidental match
# against a computer's name.
_PLATFORM_INFO = [
    platform.machine(),
    platform.platform(),
    platform.platform(aliased=1),
    platform.platform(terse=1),
    platform.system(),
    ",".join(platform.architecture()),
    ",".join(platform.uname()),
]


class RpcTest:
    """Convenience class for RCP tests and disabled/skipped tests"""

    def __init__(self, obj):
        if isinstance(obj, RpcTest):
            self.name = obj.name
            self.args = obj.args
            self.disabled = obj.disabled
            self.reason = obj.reason
            self.skip_platforms = obj.skip_platforms
        else:
            words = str(obj).split(" ")  # need to split args
            self.name = words[0]
            if len(words) > 1:
                self.args = words[1:]
            else:
                self.args = []
            self.disabled = False
            self.reason = None
            self.skip_platforms = []

    def is_disabled(self):
        """returns True if test is explicitly disabled (completely)"""
        return self.disabled

    def is_skipped(self):
        """returns True if test would skip on this platform"""
        for platform_to_skip in self.skip_platforms:
            for p in _PLATFORM_INFO:
                if platform_to_skip.lower() in p.lower().split(","):
                    return True
        return False

    def disable(self, reason):
        """set test to explicitly disabled (completely)"""
        self.disabled = True
        self.reason = reason

    def skip(self, platforms, reason):
        """set test to skip on certain platforms"""
        self.reason = reason
        if isinstance(platforms, (tuple, list)):
            for i in platforms:
                self.skip_platforms.append(i)
        else:
            self.skip_platforms.append(platforms)

    def __repr__(self):
        retval = self.name
        if self.args:
            retval = " ".join(
                [
                    retval,
                ]
                + self.args
            )
        return retval

    def __str__(self):
        return repr(self)


def disabled(test_name, reason):
    """create a disabled test"""
    assert reason, "disabling a test requires a reason!"
    rpctest = RpcTest(test_name)
    rpctest.disable(reason)
    return rpctest


def skip(test_name, platforms, reason):
    """create a test which is skipped on certain platforms.
    The 'platforms' parameter can be a string or tuple/list of strings
    which are matched against platform identifiers obtained when
    the test is executed.
    """
    assert reason, "skipping a test on some platforms requires a reason!"
    rpctest = RpcTest(test_name)
    rpctest.skip(platforms, reason)
    return rpctest