Codebase list pypsrp / master tests / test_utils.py
master

Tree @master (Download .tar.gz)

test_utils.py @master — raw · history · blame 

  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
import pytest

from six import PY3

from pypsrp._utils import to_bytes, to_string, to_unicode, \
    version_equal_or_newer, get_hostname


def test_unicode_to_bytes_default():
    expected = b"\x61\x62\x63"
    actual = to_bytes(u"abc")
    assert actual == expected


def test_unicode_to_bytes_diff_encoding():
    expected = b"\x61\x00\x62\x00\x63\x00"
    actual = to_bytes(u"abc", encoding='utf-16-le')
    assert actual == expected


def test_bytes_to_bytes():
    expected = b"\x01\x02\x03\x04"
    actual = to_bytes(b"\x01\x02\x03\x04")
    assert actual == expected


def test_str_to_bytes():
    # Python 3 the default string type is unicode so the expected value will
    # be "abc" in UTF-16 form while Python 2 "abc" is the bytes representation
    # already
    if PY3:
        expected = b"\x61\x00\x62\x00\x63\x00"
    else:
        expected = b"\x61\x62\x63"
    actual = to_bytes("abc", encoding='utf-16-le')
    assert actual == expected


def test_unicode_to_unicode():
    expected = u"abc"
    actual = to_unicode(u"abc")
    assert actual == expected


def test_byte_to_unicode():
    expected = u"abc"
    actual = to_unicode(b"\x61\x62\x63")
    assert actual == expected


def test_byte_to_unicode_diff_encoding():
    expected = u"abc"
    actual = to_unicode(b"\x61\x00\x62\x00\x63\x00", encoding='utf-16-le')
    assert actual == expected


def test_str_to_unicode():
    if PY3:
        expected = u"a\x00b\x00c\x00"
    else:
        expected = u"abc"
    actual = to_unicode("a\x00b\x00c\x00", encoding='utf-16-le')
    assert actual == expected


def test_to_str():
    if PY3:
        assert str(to_string).startswith("<function to_unicode")
    else:
        assert to_string.func_name == "to_bytes"


@pytest.mark.parametrize('version, reference_version, expected',
                         [
                             ["2.2", "2.3", False],
                             ["2.3", "2.3", True],
                             ["2.4", "2.3", True],
                             ["3", "2.3", True],
                             ["3.0", "2.3", True],
                             ["1", "2.3", False],
                             ["1.0", "2.3", False],
                             ["2.3.0", "2.3", True],
                             ["2.3.1", "2.3", True],
                             ["2.3", "2.3.0", True],
                             ["2.3", "2.3.1", False],
                         ])
def test_version_newer(version, reference_version, expected):
    assert version_equal_or_newer(version, reference_version) == expected


@pytest.mark.parametrize('url, expected',
                         [
                             # hostname
                             ['http://hostname', 'hostname'],
                             ['https://hostname', 'hostname'],
                             ['http://hostname:1234', 'hostname'],
                             ['https://hostname:1234', 'hostname'],
                             ['http://hostname/path', 'hostname'],
                             ['https://hostname/path', 'hostname'],
                             ['http://hostname:1234/path', 'hostname'],
                             ['https://hostname:1234/path', 'hostname'],

                             # fqdn
                             ['http://hostname.domain.com', 'hostname.domain.com'],
                             ['https://hostname.domain.com', 'hostname.domain.com'],
                             ['http://hostname.domain.com:1234', 'hostname.domain.com'],
                             ['https://hostname.domain.com:1234', 'hostname.domain.com'],
                             ['http://hostname.domain.com/path', 'hostname.domain.com'],
                             ['https://hostname.domain.com/path', 'hostname.domain.com'],
                             ['http://hostname.domain.com:1234/path', 'hostname.domain.com'],
                             ['https://hostname.domain.com:1234/path', 'hostname.domain.com'],

                             # ip address
                             ['http://1.2.3.4', '1.2.3.4'],
                             ['https://1.2.3.4', '1.2.3.4'],
                             ['http://1.2.3.4:1234', '1.2.3.4'],
                             ['https://1.2.3.4:1234', '1.2.3.4'],
                             ['http://1.2.3.4/path', '1.2.3.4'],
                             ['https://1.2.3.4/path', '1.2.3.4'],
                             ['http://1.2.3.4:1234/path', '1.2.3.4'],
                             ['https://1.2.3.4:1234/path', '1.2.3.4'],
                         ])
def test_get_hostname(url, expected):
    assert expected == get_hostname(url)