Exemple #1
0
    def testExtractMastersMultiple(self):
        """
        Test extracting from master provided according to syntax for opts['master']
        """
        console.terse("{0}\n".format(self.testExtractMastersMultiple.__doc__))

        master = ["localhost", "10.0.2.23", "me.example.com"]
        self.opts.update(master=master)
        self.assertEquals(
            extract_masters(self.opts),
            [
                {"external": ("localhost", 4506), "internal": None},
                {"external": ("10.0.2.23", 4506), "internal": None},
                {"external": ("me.example.com", 4506), "internal": None},
            ],
        )

        master = ["localhost 4510", "10.0.2.23 4510", "me.example.com 4510"]
        self.opts.update(master=master)
        self.assertEquals(
            extract_masters(self.opts),
            [
                {"external": ("localhost", 4510), "internal": None},
                {"external": ("10.0.2.23", 4510), "internal": None},
                {"external": ("me.example.com", 4510), "internal": None},
            ],
        )

        master = [
            {"external": "localhost 4510", "internal": ""},
            {"external": "me.example.com 4510", "internal": "10.0.2.23 4510"},
            {"external": "you.example.com 4509"},
        ]
        self.opts.update(master=master)
        self.assertEquals(
            extract_masters(self.opts),
            [
                {"external": ("localhost", 4510), "internal": None},
                {"external": ("me.example.com", 4510), "internal": ("10.0.2.23", 4510)},
                {"external": ("you.example.com", 4509), "internal": None},
            ],
        )
Exemple #2
0
    def testExtractMastersMultiple(self):
        '''
        Test extracting from master provided according to syntax for opts['master']
        '''
        console.terse("{0}\n".format(self.testExtractMastersMultiple.__doc__))

        master = ['localhost', '10.0.2.23', 'me.example.com']
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            {
                'external': ('localhost', 4506),
                'internal': None
            },
            {
                'external': ('10.0.2.23', 4506),
                'internal': None
            },
            {
                'external': ('me.example.com', 4506),
                'internal': None
            },
        ])

        master = ['localhost 4510', '10.0.2.23 4510', 'me.example.com 4510']
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            {
                'external': ('localhost', 4510),
                'internal': None
            },
            {
                'external': ('10.0.2.23', 4510),
                'internal': None
            },
            {
                'external': ('me.example.com', 4510),
                'internal': None
            },
        ])

        master = [{
            'external': 'localhost 4510',
            'internal': '',
        }, {
            'external': 'me.example.com 4510',
            'internal': '10.0.2.23 4510',
        }, {
            'external': 'you.example.com 4509',
        }]
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            {
                'external': ('localhost', 4510),
                'internal': None
            },
            {
                'external': ('me.example.com', 4510),
                'internal': ('10.0.2.23', 4510)
            },
            {
                'external': ('you.example.com', 4509),
                'internal': None
            },
        ])
Exemple #3
0
    def testExtractMastersSingle(self):
        """
        Test extracting from master provided according to syntax for opts['master']
        """
        console.terse("{0}\n".format(self.testExtractMastersSingle.__doc__))

        master = "localhost"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("localhost", 4506), internal=None)])

        master = "127.0.0.1"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("127.0.0.1", 4506), internal=None)])

        master = "localhost 4510"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("localhost", 4510), internal=None)])

        master = "127.0.0.1 4510"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("127.0.0.1", 4510), internal=None)])

        master = "10.0.2.23"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("10.0.2.23", 4506), internal=None)])

        master = "me.example.com"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("me.example.com", 4506), internal=None)])

        master = "10.0.2.23 4510"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("10.0.2.23", 4510), internal=None)])

        master = "me.example.com 4510"
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("me.example.com", 4510), internal=None)])

        master = dict(external="10.0.2.23 4510")
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("10.0.2.23", 4510), internal=None)])

        master = dict(external="10.0.2.23 4510", internal="")
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [dict(external=("10.0.2.23", 4510), internal=None)])

        master = dict(internal="10.0.2.23 4510")
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [])
Exemple #4
0
    def testExtractMastersSingle(self):
        '''
        Test extracting from master provided according to syntax for opts['master']
        '''
        console.terse("{0}\n".format(self.testExtractMastersSingle.__doc__))

        master = 'localhost'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('localhost', 4506), internal=None),
        ])

        master = '127.0.0.1'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('127.0.0.1', 4506), internal=None),
        ])

        master = 'localhost 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('localhost', 4510), internal=None),
        ])

        master = '127.0.0.1 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('127.0.0.1', 4510), internal=None),
        ])

        master = '10.0.2.23'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('10.0.2.23', 4506), internal=None),
        ])

        master = 'me.example.com'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('me.example.com', 4506), internal=None),
        ])

        master = '10.0.2.23 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('10.0.2.23', 4510), internal=None),
        ])

        master = 'me.example.com 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('me.example.com', 4510), internal=None),
        ])

        master = dict(external='10.0.2.23 4510')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('10.0.2.23', 4510), internal=None),
        ])

        master = dict(external='10.0.2.23 4510', internal='')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [
            dict(external=('10.0.2.23', 4510), internal=None),
        ])

        master = dict(internal='10.0.2.23 4510')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts), [])
Exemple #5
0
 def postinitio(self):
     self.masters = daemons.extract_masters(self.opts.value)
Exemple #6
0
 def postinitio(self):
     self.masters = daemons.extract_masters(self.opts.value)
    def testExtractMastersMultiple(self):
        '''
        Test extracting from master provided according to syntax for opts['master']
        '''
        console.terse("{0}\n".format(self.testExtractMastersMultiple.__doc__))

        master = [
                    'localhost',
                    '10.0.2.23',
                    'me.example.com'
                 ]
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                            {
                                'external': ('localhost', 4506),
                                'internal': None
                            },
                            {
                                'external': ('10.0.2.23', 4506),
                                'internal': None
                            },
                            {
                                'external': ('me.example.com', 4506),
                                'internal': None
                            },
                          ])

        master = [
                    'localhost 4510',
                    '10.0.2.23 4510',
                    'me.example.com 4510'
                 ]
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                            {
                                'external': ('localhost', 4510),
                                'internal': None
                            },
                            {
                                'external': ('10.0.2.23', 4510),
                                'internal': None
                            },
                            {
                                'external': ('me.example.com', 4510),
                                'internal': None
                            },
                          ])

        master = [
                    {
                        'external': 'localhost 4510',
                        'internal': '',
                    },
                    {
                        'external': 'me.example.com 4510',
                        'internal': '10.0.2.23 4510',
                    },
                    {
                        'external': 'you.example.com 4509',
                    }
                 ]
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                            {
                                'external': ('localhost', 4510),
                                'internal': None
                            },
                            {
                                'external': ('me.example.com', 4510),
                                'internal': ('10.0.2.23', 4510)
                            },
                            {
                                'external': ('you.example.com', 4509),
                                'internal': None
                            },
                          ])
    def testExtractMastersSingle(self):
        '''
        Test extracting from master provided according to syntax for opts['master']
        '''
        console.terse("{0}\n".format(self.testExtractMastersSingle.__doc__))

        master = 'localhost'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                              dict(external=('localhost', 4506),
                                   internal=None),
                          ])

        master = '127.0.0.1'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                              dict(external=('127.0.0.1', 4506),
                                   internal=None),
                          ])

        master = 'localhost 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                              dict(external=('localhost', 4510),
                                   internal=None),
                          ])

        master = '127.0.0.1 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                              dict(external=('127.0.0.1', 4510),
                                   internal=None),
                          ])


        master = '10.0.2.23'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                          [
                              dict(external=('10.0.2.23', 4506),
                                   internal=None),
                          ])

        master = 'me.example.com'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                                  [
                                      dict(external=('me.example.com', 4506),
                                           internal=None),
                                  ])

        master = '10.0.2.23 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                                  [
                                      dict(external=('10.0.2.23', 4510),
                                           internal=None),
                                  ])

        master = 'me.example.com 4510'
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                                  [
                                      dict(external=('me.example.com', 4510),
                                           internal=None),
                                  ])

        master = dict(external='10.0.2.23 4510')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                                  [
                                      dict(external=('10.0.2.23', 4510),
                                           internal=None),
                                  ])

        master = dict(external='10.0.2.23 4510', internal='')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),
                                  [
                                      dict(external=('10.0.2.23', 4510),
                                           internal=None),
                                  ])

        master = dict(internal='10.0.2.23 4510')
        self.opts.update(master=master)
        self.assertEquals(extract_masters(self.opts),[])