← Back to branch summary

~ubuntu-branches/ubuntu/precise/debtags/precise-proposed

« back to all changes in this revision

Viewing changes to test/test_hw.py

  • Committer: Package Import Robot
  • Author(s): Michael Vogt
  • Date: 2012-02-13 10:33:06 UTC
  • Revision ID: package-import@ubuntu.com-20120213103306-71cdhoe5b0zb5r1k
Tags: 1.8.0+git20120213ubuntu1
* updated git snapshot:
  - include new debtags-hardware command
  - include support for postive/negative match generator

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_hw.py
31
31
import sys
32
32
sys.path.insert(0, "../")
33
33
 
34
 
from debtagshw.debtagshw import DebtagsAvailableHW, HardwareSupported
 
34
from debtagshw.detectors import (
 
35
    Detector,
 
36
    DetectorCmdline,
 
37
)
 
38
 
 
39
from debtagshw.debtagshw import (
 
40
    DebtagsAvailableHW,
 
41
    HardwareSupported,
 
42
    )
35
43
 
36
44
class TestDebtagsHW(unittest.TestCase):
37
45
 
38
46
    def test__check_hw_debtags(self):
39
47
        hw = DebtagsAvailableHW()
40
48
        # run over all hwtags that we support
41
 
        for hwtag in [ 
42
 
            # done
43
 
            "hardware::input:mouse",
44
 
            "hardware::input:keyboard",
45
 
            "hardware::input:touchscreen",
46
 
            "hardware::storage:cd",
47
 
            "hardware::storage:cd:writer",
48
 
            "hardware::storage:dvd",
49
 
            "hardware::storage:dvd:writer",
50
 
            "hardware::video:opengl",
51
 
            "hardware::laptop",
52
 
            "hardware::printer",
53
 
            "hardware::scanner",
 
49
        for hwtag in hw.get_supported_tags() + [
54
50
            # TODO
55
51
            "hardware::camera",
56
52
            "hardware::gps",
67
63
        self.assertTrue(hw._check_hw_debtag("hardware::input:keyboard"))
68
64
    
69
65
    def test_laptop_detect(self):
70
 
        hw = DebtagsAvailableHW()
71
 
        hw.LAPTOP_DETECT = "/bin/true"
72
 
        self.assertTrue(hw._check_hw_debtag("hardware::laptop"))
73
 
        hw.LAPTOP_DETECT = "/bin/false"
74
 
        self.assertFalse(hw._check_hw_debtag("hardware::laptop"))
 
66
        d = DetectorCmdline()
 
67
        d.LAPTOP_DETECT = "/bin/true"
 
68
        self.assertEqual(d.is_supported("hardware::laptop"),
 
69
                        HardwareSupported.YES)
 
70
        d.LAPTOP_DETECT = "/bin/false"
 
71
        self.assertEqual(d.is_supported("hardware::laptop"),
 
72
                         HardwareSupported.NO)
75
73
 
76
74
    def test_scanner(self):
77
75
        f = tempfile.NamedTemporaryFile()
78
76
        f.write("device 'uri' is a foo bar bar")
79
77
        f.flush()
80
 
        hw = DebtagsAvailableHW()
81
 
        hw.SCANIMAGE = ["cat", f.name]
82
 
        self.assertTrue(hw._check_hw_debtag("hardware::scanner"))
83
 
        hw.SCANIMAGE = ["cat", "/dev/null"]
84
 
        self.assertFalse(hw._check_hw_debtag("hardware::scanner"))
 
78
        d = DetectorCmdline()
 
79
        d.SCANIMAGE = ["cat", f.name]
 
80
        self.assertEqual(d.is_supported("hardware::scanner"),
 
81
                         HardwareSupported.YES)
 
82
        d.SCANIMAGE = ["cat", "/dev/null"]
 
83
        self.assertEqual(d.is_supported("hardware::scanner"),
 
84
                         HardwareSupported.NO)
 
85
 
 
86
class TestPublicAPI(unittest.TestCase):
 
87
 
 
88
    def setUp(self):
 
89
        class MockDetector(Detector):
 
90
            TEST_TAGS = {  "hardware::scanner" : HardwareSupported.YES,
 
91
                           "hardware::printer":  HardwareSupported.NO,
 
92
                           "hardware::gps":  HardwareSupported.NO,
 
93
                           "hardware::testme1":  HardwareSupported.NO,
 
94
                           "hardware::testme2":  HardwareSupported.YES,
 
95
                    }
 
96
            def get_supported_tags(self):
 
97
                return self.TEST_TAGS.keys()
 
98
            def is_supported(self, tag):
 
99
                if tag in self.TEST_TAGS:
 
100
                    return self.TEST_TAGS[tag]
 
101
                return HardwareSupported.UNKNOWN
 
102
        self._mock_detector = MockDetector()
 
103
        self.hw = DebtagsAvailableHW()
 
104
        self.hw._detectors.insert(0, self._mock_detector)
85
105
 
86
106
    def test_get_missing_hw(self):
87
 
        #env
88
 
        hw = DebtagsAvailableHW()
89
 
        hw._hardware__scanner = lambda:True
90
 
        hw._hardware__gps = lambda:False
91
107
        # test
92
108
        tags = ["hardware::scanner", "hardware::gps", "hardware::xxx" ]
93
 
        result = hw.get_hardware_support_for_tags(tags)
 
109
        result = self.hw.get_hardware_support_for_tags(tags)
94
110
        self.assertEqual(result, {
95
111
            'hardware::scanner' : HardwareSupported.YES,
96
112
            'hardware::gps' : HardwareSupported.NO,
97
 
            'hardware::xxx' : HardwareSupported.UNKOWN,
 
113
            'hardware::xxx' : HardwareSupported.UNKNOWN,
98
114
            })
99
115
        
 
116
    def test_generate_tag_expressions(self):
 
117
        res = {}
 
118
        # test
 
119
        for supported, tags in self.hw.generate_tag_expressions():
 
120
            for tag in tags:
 
121
                res[tag] = supported
 
122
        self.assertEqual(res["hardware::testme2"], "yes")
 
123
        self.assertEqual(res["hardware::testme1"], "no")
100
124
 
101
125
class TestCasePrinter(unittest.TestCase):
102
126
 
112
136
        with patch.dict('sys.modules', { 'cups' : cups_mock }):
113
137
            hw = DebtagsAvailableHW()
114
138
            cups_connection_mock.getPrinters.return_value = {}
115
 
            self.assertFalse(hw._check_hw_debtag("hardware::printer"))
 
139
            self.assertEqual(hw._check_hw_debtag("hardware::printer"),
 
140
                             HardwareSupported.NO)
116
141
            cups_connection_mock.getPrinters.return_value = { 
117
142
                'deskjet' : { 'print-info' : "some info",
118
143
                            },
119
144
                }
120
 
            self.assertTrue(hw._check_hw_debtag("hardware::printer"))
 
145
            self.assertEqual(hw._check_hw_debtag("hardware::printer"),
 
146
                            HardwareSupported.YES)
121
147
 
122
148
if __name__ == "__main__":
123
149
    logging.basicConfig(level=logging.INFO)