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