uwledclient/test.py at main · spierepf/uwledclient · GitHub

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

import install

if 'unittest' not in os.listdir(install.libpath):
    import mip

    mip.install('unittest', target=install.libpath)

if 'mock.py' not in os.listdir(install.libpath + "/unittest"):
    import mip

    mip.install('github:spierepf/umock', target=install.libpath)

import unittest
from unittest.mock import Mock

from uwledclient import SegmentBuilder


class TestSegmentBuilder(unittest.TestCase):
    def test_segmentbuilder_invokes_callback_when_done(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).done()
        assert callback.call_args[0][0] is not None

    def test_segmentbuilder_creates_maxseg_segments(self):
        for maxseg in [1, 2]:
            callback = Mock()
            SegmentBuilder(maxseg, 1, {'Solid': 0}, {}, callback).done()
            assert len(callback.call_args[0][0]) == maxseg
            for i in range(maxseg):
                assert callback.call_args[0][0][i]['id'] == i
                assert callback.call_args[0][0][i]['stop'] == 0

    def test_segmentbuilder_first_segment_starts_at_zero(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).next().done()
        assert callback.call_args[0][0][0]['start'] == 0

    def test_segmentbuilder_segment_defaults_to_using_all_leds(self):
        for led_count in [1, 2]:
            callback = Mock()
            SegmentBuilder(1, led_count, {'Solid': 0}, {}, callback).next().done()
            assert callback.call_args[0][0][0]['stop'] == led_count

    def test_segmentbuilder_defaults_to_solid_black(self):
        for effect_id in range(2):
            callback = Mock()
            SegmentBuilder(1, 1, {'Solid': effect_id}, {}, callback).next().done()
            assert callback.call_args[0][0][0]['fx'] == effect_id
            assert callback.call_args[0][0][0]['col'] == [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

    def test_segmentbuilder_length(self):
        for led_count in [5, 6]:
            for first_segment_length in [1, 2]:
                for second_segment_length in [1, 2]:
                    callback = Mock()
                    (SegmentBuilder(3, led_count, {'Solid': 0}, {}, callback)
                     .length(first_segment_length).next()
                     .length(second_segment_length).next()
                     .next().done())
                    assert callback.call_args[0][0][0]['start'] == 0
                    assert callback.call_args[0][0][0]['stop'] == first_segment_length
                    assert callback.call_args[0][0][1]['start'] == first_segment_length
                    assert callback.call_args[0][0][1]['stop'] == first_segment_length + second_segment_length
                    assert callback.call_args[0][0][2]['start'] == first_segment_length + second_segment_length
                    assert callback.call_args[0][0][2]['stop'] == led_count

    def test_segmentbuilder_set(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).set('bogus', 1).next().done()
        assert callback.call_args[0][0][0]['bogus'] == 1

    def test_segmentbuilder_dunder_get_attr(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).bogus(1).next().done()
        assert callback.call_args[0][0][0]['bogus'] == 1

    def test_segmentbuilder_fx_sets_effect_by_effect_id(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0, 'Test Effect': 1}, {}, callback).fx('Test Effect').next().done()
        assert callback.call_args[0][0][0]['fx'] == 1

    def test_segmentbuilder_fx_special_strings(self):
        for special_string in ['~', '~-', 'r']:
            callback = Mock()
            SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).fx(special_string).next().done()
            assert callback.call_args[0][0][0]['fx'] == special_string

    def test_segmentbuilder_pal_sets_palette_by_palette_id(self):
        callback = Mock()
        SegmentBuilder(1, 1, {'Solid': 0}, {'Test Palette': 1}, callback).pal('Test Palette').next().done()
        assert callback.call_args[0][0][0]['pal'] == 1

    def test_segmentbuilder_pal_special_strings(self):
        for special_string in ['~', '~-', 'r']:
            callback = Mock()
            SegmentBuilder(1, 1, {'Solid': 0}, {}, callback).pal(special_string).next().done()
            assert callback.call_args[0][0][0]['pal'] == special_string


if __name__ == "__main__":
    unittest.main()