tests/test_srcformats.py

   1 #!/usr/bin/env python
   2
   3 import unittest
   4
   5 import os, sys
   6 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
   7
   8 from collections import defaultdict
   9
  10 from daklib import srcformats
  11 from daklib.dak_exceptions import UnknownFormatError
  12
  13 class SourceFormatTestCase(unittest.TestCase):
  14     def get_rejects(self, has_vars):
  15         has = defaultdict(lambda: 0)
  16         has.update(has_vars)
  17         return list(self.fmt.reject_msgs(has))
  18
  19     def assertAccepted(self, has):
  20         self.assertEqual(self.get_rejects(has), [])
  21
  22     def assertRejected(self, has):
  23         self.assertNotEqual(self.get_rejects(has), [])
  24
  25 class FormatOneTestCase(SourceFormatTestCase):
  26     fmt = srcformats.FormatOne
  27
  28     def testEmpty(self):
  29         self.assertRejected({})
  30
  31     def testNative(self):
  32         self.assertAccepted({'native_tar': 1, 'native_tar_gz': 1})
  33
  34     def testStandard(self):
  35         self.assertAccepted({
  36             'orig_tar': 1,
  37             'orig_tar_gz': 1,
  38             'debian_diff': 1,
  39         })
  40
  41     def testDisallowed(self):
  42         self.assertRejected({
  43             'native_tar': 1,
  44             'native_tar_gz': 1,
  45             'debian_tar': 1,
  46         })
  47         self.assertRejected({
  48             'orig_tar': 1,
  49             'orig_tar_gz': 1,
  50             'debian_diff': 0,
  51         })
  52         self.assertRejected({
  53             'native_tar': 1,
  54             'native_tar_gz': 1,
  55             'more_orig_tar': 1,
  56         })
  57         self.assertRejected({
  58             'native_tar': 1,
  59             'native_tar_gz': 1,
  60             'debian_diff': 1,
  61         })
  62
  63 class FormatTreeTestCase(SourceFormatTestCase):
  64     fmt = srcformats.FormatThree
  65
  66     def testEmpty(self):
  67         self.assertRejected({})
  68
  69     def testSimple(self):
  70         self.assertAccepted({'native_tar': 1})
  71
  72     def testDisallowed(self):
  73         self.assertRejected({'native_tar': 1, 'orig_tar': 1})
  74         self.assertRejected({'native_tar': 1, 'debian_diff': 1})
  75         self.assertRejected({'native_tar': 1, 'debian_tar': 1})
  76         self.assertRejected({'native_tar': 1, 'more_orig_tar': 1})
  77
  78 class FormatTreeQuiltTestCase(SourceFormatTestCase):
  79     fmt = srcformats.FormatThreeQuilt
  80
  81     def testEmpty(self):
  82         self.assertRejected({})
  83
  84     def testSimple(self):
  85         self.assertAccepted({'orig_tar': 1, 'debian_tar': 1})
  86
  87     def testMultipleTarballs(self):
  88         self.assertAccepted({
  89             'orig_tar': 1,
  90             'debian_tar': 1,
  91             'more_orig_tar': 42,
  92         })
  93
  94     def testDisallowed(self):
  95         self.assertRejected({
  96             'orig_tar': 1,
  97             'debian_tar': 1,
  98             'debian_diff': 1
  99         })
 100         self.assertRejected({
 101             'orig_tar': 1,
 102             'debian_tar': 1,
 103             'native_tar': 1,
 104         })
 105
 106 ##
 107
 108 class ParseFormatTestCase(unittest.TestCase):
 109     def assertParse(self, format, expected):
 110         self.assertEqual(srcformats.parse_format(format), expected)
 111
 112     def assertParseFail(self, format):
 113         self.assertRaises(
 114             UnknownFormatError,
 115             lambda: srcformats.parse_format(format)
 116         )
 117
 118     def testParse(self):
 119         self.assertParse('1.0', (1, 0))
 120
 121     def testEmpty(self):
 122         self.assertParseFail('')
 123         self.assertParseFail(' ')
 124         self.assertParseFail('  ')
 125
 126     def textText(self):
 127         self.assertParse('1.2 (three)', (1, 2, 'three'))
 128         self.assertParseFail('0.0 ()')
 129
 130 class ValidateFormatTestCase(unittest.TestCase):
 131     def assertValid(self, format, **kwargs):
 132         kwargs['is_a_dsc'] = kwargs.get('is_a_dsc', True)
 133         self.fmt.validate_format(format, **kwargs)
 134
 135     def assertInvalid(self, *args, **kwargs):
 136         self.assertRaises(
 137             UnknownFormatError,
 138             lambda: self.assertValid(*args, **kwargs),
 139         )
 140
 141 class ValidateFormatOneTestCase(ValidateFormatTestCase):
 142     fmt = srcformats.FormatOne
 143
 144     def testValid(self):
 145         self.assertValid((1, 0))
 146
 147     def testInvalid(self):
 148         self.assertInvalid((0, 1))
 149         self.assertInvalid((3, 0, 'quilt'))
 150
 151     ##
 152
 153     def testBinary(self):
 154         self.assertValid((1, 5), is_a_dsc=False)
 155         self.assertInvalid((1, 0), is_a_dsc=False)
 156
 157     def testRange(self):
 158         self.assertInvalid((1, 3), is_a_dsc=False)
 159         self.assertValid((1, 5), is_a_dsc=False)
 160         self.assertValid((1, 8), is_a_dsc=False)
 161         self.assertInvalid((1, 9), is_a_dsc=False)
 162
 163     def testFilesField(self):
 164         self.assertInvalid((1, 7), is_a_dsc=False, field='notfiles')
 165         self.assertValid((1, 8), is_a_dsc=False, field='notfiles')
 166
 167 class ValidateFormatThreeTestCase(ValidateFormatTestCase):
 168     fmt = srcformats.FormatThree
 169
 170     def testValid(self):
 171         self.assertValid((3, 0, 'native'))
 172
 173     def testInvalid(self):
 174         self.assertInvalid((1, 0))
 175         self.assertInvalid((0, 0))
 176         self.assertInvalid((3, 0, 'quilt'))
 177
 178 class ValidateFormatThreeQuiltTestCase(ValidateFormatTestCase):
 179     fmt = srcformats.FormatThreeQuilt
 180
 181     def testValid(self):
 182         self.assertValid((3, 0, 'quilt'))
 183
 184     def testInvalid(self):
 185         self.assertInvalid((1, 0))
 186         self.assertInvalid((0, 0))
 187         self.assertInvalid((3, 0, 'native'))
 188
 189 class FormatFromStringTestCase(unittest.TestCase):
 190     def assertFormat(self, txt, klass):
 191         self.assertEqual(srcformats.get_format_from_string(txt), klass)
 192
 193     def assertInvalid(self, txt):
 194         self.assertRaises(
 195             UnknownFormatError,
 196             lambda: srcformats.get_format_from_string(txt),
 197         )
 198
 199     def testFormats(self):
 200         self.assertFormat('1.0', srcformats.FormatOne)
 201         self.assertFormat('3.0 (native)', srcformats.FormatThree)
 202         self.assertFormat('3.0 (quilt)', srcformats.FormatThreeQuilt)
 203
 204     def testInvalidFormats(self):
 205         self.assertInvalid('')
 206         self.assertInvalid('.')
 207         self.assertInvalid('3.0 (cvs)')
 208         self.assertInvalid(' 1.0 ')
 209         self.assertInvalid('8.4 (hardy)')
 210
 211 if __name__ == '__main__':
 212     unittest.main()