コード例 #1
0
    def test_from_stream(self):
        conf = Configuration.from_stream(StringIO(self.TEST_CONFIGURATION))

        p1 = conf.get_policy(1)
        self.assertEqual(p1.index, 1)
        self.assertEqual(
            list(p1.read_set),
            [Ring('sfo-arc6+3', 'sfo', ['http://sfo1.int/arc6+3'])])
        self.assertEqual(list(p1.write_set), [
            Ring('paris-arc6+3', 'paris',
                 ['http://paris1.int/arc6+3', 'http://paris2.int/arc6+3'])
        ])

        p2 = conf.get_policy(2)
        self.assertEqual(
            p2,
            StoragePolicy(2, [
                Ring('nyc-arc6+3', 'nyc', ['http://nyc1.int/arc6+3'])
            ], [
                Ring('paris-arc6+3', 'paris',
                     ['http://paris1.int/arc6+3', 'http://paris2.int/arc6+3'])
            ]))

        p3 = conf.get_policy(3)
        self.assertEqual(
            p3,
            StoragePolicy(3, [], [
                Ring('paris-rep3', 'paris',
                     ['http://paris1.int/rep3', 'http://paris2.int/rep3'])
            ]))

        self.assertRaises(ValueError, conf.get_policy, 4)
        self.assertRaises(ValueError, conf.get_policy, 'test')
コード例 #2
0
    def test_eq(self):
        index = 1
        read_set = [Ring('paris-arc6+3', 'paris', ['http://paris'])]
        write_set = [Ring('london-arc6+3', 'london', ['http://london'])]

        sp1 = StoragePolicy(index, read_set, write_set)
        sp2 = StoragePolicy(index, read_set, write_set)

        self.assertEqual(sp1, sp2)
コード例 #3
0
 def test_hash_equal(self):
     self.assertEqual(
         hash(
             StoragePolicy(1, [
                 Ring('paris-arc6+3', 'paris',
                      ['http://paris1', 'http://paris2']),
                 Ring('london-arc6+3', 'london',
                      ['http://london1', 'http://london2'])
             ], [Ring('paris-chord3', 'paris', ['http://paris3'])])),
         hash(
             StoragePolicy(1, [
                 Ring('london-arc6+3', 'london',
                      ['http://london2', 'http://london1']),
                 Ring('paris-arc6+3', 'paris',
                      ['http://paris1', 'http://paris2'])
             ], [Ring('paris-chord3', 'paris', ['http://paris3'])])))
コード例 #4
0
    def test_ne(self):
        self.assertNotEqual(StoragePolicy(1, [], []), StoragePolicy(2, [], []))

        self.assertNotEqual(
            StoragePolicy(1, [Ring('paris-arc6+3', 'paris', [])], []),
            StoragePolicy(1, [Ring('london-arc6+3', 'london', [])], []))

        self.assertNotEqual(
            StoragePolicy(1, [], [Ring('paris-arc6+3', 'paris', [])]),
            StoragePolicy(1, [], []))
コード例 #5
0
    def test_hash_equal(self):
        p = StoragePolicy(1, [], [])

        self.assertEqual(hash(Configuration([p])), hash(Configuration([p])))
コード例 #6
0
 def test_ne(self):
     self.assertNotEqual(Configuration([StoragePolicy(1, [], [])]),
                         Configuration([]))
コード例 #7
0
    def test_duplicate_index(self):
        p1 = StoragePolicy(1, [], [])
        p2 = StoragePolicy(2, [], [])
        p3 = StoragePolicy(1, [], [])

        self.assertRaises(ValueError, Configuration, [p1, p2, p3])
コード例 #8
0
 def test_lookup_method_invalid(self):
     self.assertRaises(ValueError, StoragePolicy(1, [], []).lookup, 'test')
コード例 #9
0
 def test_hash_not_equal(self):
     self.assertNotEqual(hash(StoragePolicy(1, [], [])),
                         hash(StoragePolicy(2, [], [])))
コード例 #10
0
 def test_ne_not_implemented(self):
     self.assertNotEqual(StoragePolicy(1, [], []), 1)
コード例 #11
0
 def test_eq_not_implemented(self):
     self.assertFalse(StoragePolicy(1, [], []) == 1)
コード例 #12
0
class TestStoragePolicy(unittest.TestCase):
    def test_eq(self):
        index = 1
        read_set = [Ring('paris-arc6+3', 'paris', ['http://paris'])]
        write_set = [Ring('london-arc6+3', 'london', ['http://london'])]

        sp1 = StoragePolicy(index, read_set, write_set)
        sp2 = StoragePolicy(index, read_set, write_set)

        self.assertEqual(sp1, sp2)

    def test_eq_not_implemented(self):
        self.assertFalse(StoragePolicy(1, [], []) == 1)

    def test_ne(self):
        self.assertNotEqual(StoragePolicy(1, [], []), StoragePolicy(2, [], []))

        self.assertNotEqual(
            StoragePolicy(1, [Ring('paris-arc6+3', 'paris', [])], []),
            StoragePolicy(1, [Ring('london-arc6+3', 'london', [])], []))

        self.assertNotEqual(
            StoragePolicy(1, [], [Ring('paris-arc6+3', 'paris', [])]),
            StoragePolicy(1, [], []))

    def test_ne_not_implemented(self):
        self.assertNotEqual(StoragePolicy(1, [], []), 1)

    def test_hash_equal(self):
        self.assertEqual(
            hash(
                StoragePolicy(1, [
                    Ring('paris-arc6+3', 'paris',
                         ['http://paris1', 'http://paris2']),
                    Ring('london-arc6+3', 'london',
                         ['http://london1', 'http://london2'])
                ], [Ring('paris-chord3', 'paris', ['http://paris3'])])),
            hash(
                StoragePolicy(1, [
                    Ring('london-arc6+3', 'london',
                         ['http://london2', 'http://london1']),
                    Ring('paris-arc6+3', 'paris',
                         ['http://paris1', 'http://paris2'])
                ], [Ring('paris-chord3', 'paris', ['http://paris3'])])))

    def test_hash_not_equal(self):
        self.assertNotEqual(hash(StoragePolicy(1, [], [])),
                            hash(StoragePolicy(2, [], [])))

    LOOKUP_TEST_POLICY = StoragePolicy(
        index=1,
        read_set=[
            Ring(name='sfo-arc6+3',
                 location=Location(name='sfo'),
                 endpoints=[Endpoint(url='http://sfo1.int/arc6+3')])
        ],
        write_set=[
            Ring(name='paris-arc6+3',
                 location=Location(name='paris'),
                 endpoints=[
                     Endpoint(url='http://paris1.int/arc6+3'),
                     Endpoint(url='http://paris2.int/arc6+3')
                 ])
        ])

    def test_lookup_method_invalid(self):
        self.assertRaises(ValueError, StoragePolicy(1, [], []).lookup, 'test')

    def test_lookup_method_read_without_location(self):
        self.assertEqual(self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.READ), [
            frozenset([
                Endpoint('http://sfo1.int/arc6+3'),
                Endpoint('http://paris1.int/arc6+3'),
                Endpoint('http://paris2.int/arc6+3')
            ])
        ])

    def test_lookup_method_write_without_location(self):
        self.assertEqual(self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.WRITE), [
            frozenset([
                Endpoint('http://paris1.int/arc6+3'),
                Endpoint('http://paris2.int/arc6+3')
            ])
        ])

    def test_lookup_method_read_with_location(self):
        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.READ, ['paris']), [
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3')
                ]),
                frozenset([Endpoint('http://sfo1.int/arc6+3')])
            ])

        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.READ,
                                           [Location('sfo')]),
            [
                frozenset([Endpoint('http://sfo1.int/arc6+3')]),
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3')
                ])
            ])

    def test_lookup_method_write_with_location(self):
        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.WRITE, ['paris']), [
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3')
                ])
            ])

        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.WRITE, ['sfo']), [
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3')
                ])
            ])

    def test_lookup_method_read_with_unknown_location(self):
        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.READ, ['nyc']), [
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3'),
                    Endpoint('http://sfo1.int/arc6+3')
                ])
            ])

    def test_lookup_method_write_with_unknown_location(self):
        self.assertEqual(
            self.LOOKUP_TEST_POLICY.lookup(StoragePolicy.WRITE, ['nyc']), [
                frozenset([
                    Endpoint('http://paris1.int/arc6+3'),
                    Endpoint('http://paris2.int/arc6+3')
                ])
            ])