Beispiel #1
0
    def test_lock_unlock_lock(self, m):
        def callback_prevent(url, **kwargs):
            self.assertDictEqual(
                kwargs['json'], {
                    'scope': 'ORCHESTRATION',
                    'datemark': self.datamark,
                    'applicant': [str(self.n1.id),
                                  str(self.n2.id)]
                })
            return CallbackResult("{'message': 'Preventing lock acquired'}",
                                  status=200)

        def callback_lock(url, **kwargs):
            self.assertDictEqual(
                kwargs['json'], {
                    'scope': 'ORCHESTRATION',
                    'applicant': [str(self.n1.id),
                                  str(self.n2.id)]
                })
            return CallbackResult("{'message': 'Locked'}", status=200)

        m.post(self.n1.url('api_1_0.locker_prevent'),
               callback=callback_prevent)
        m.post(self.n2.url('api_1_0.locker_prevent'),
               callback=callback_prevent)
        m.post(self.n1.url('api_1_0.locker_lock'), callback=callback_lock)
        m.post(self.n2.url('api_1_0.locker_lock'), callback=callback_lock)

        ret = lock_unlock('L',
                          Scope.ORCHESTRATION, [self.n1, self.n2],
                          applicant=[str(self.n1.id),
                                     str(self.n2.id)],
                          identity=ROOT)

        self.assertIsNone(ret)
Beispiel #2
0
    def test_lock_unlock_lock_error_on_lock(self, m):
        m.post(self.n1.url('api_1_0.locker_prevent'),
               status=200,
               payload={'message': 'Preventing lock acquired'})
        m.post(self.n2.url('api_1_0.locker_prevent'),
               status=200,
               payload={'message': 'Preventing lock acquired'})
        m.post(self.n1.url('api_1_0.locker_lock'),
               status=200,
               payload={'message': 'Locked'})
        m.post(self.n2.url('api_1_0.locker_lock'),
               status=409,
               payload={'error': 'Unable to lock'})

        with self.assertRaises(errors.LockError) as e:
            ret = lock_unlock('L',
                              Scope.ORCHESTRATION, [self.n1, self.n2],
                              identity=ROOT)

        self.assertEqual(Scope.ORCHESTRATION, e.exception.scope)
        self.assertListEqual([
            Response(msg={'error': 'Unable to lock'},
                     code=409,
                     server=self.n2,
                     url=self.n2.url('api_1_0.locker_lock'))
        ], e.exception.responses)
Beispiel #3
0
    def test_lock_unlock_unlock_with_error(self, m):
        m.post(self.n2.url('api_1_0.locker_unlock'),
               status=200,
               payload={'message': 'UnLocked'})
        m.post(self.n1.url('api_1_0.locker_unlock'),
               status=409,
               payload={'error': 'Unable to unlock.'})

        with self.assertRaises(errors.LockError) as e:
            lock_unlock('U',
                        Scope.ORCHESTRATION, [self.n1, self.n2],
                        [str(self.n1.id), str(self.n2.id)],
                        identity=ROOT)

        self.assertEqual(Scope.ORCHESTRATION, e.exception.scope)
        self.assertListEqual([
            Response(msg={'error': 'Unable to unlock.'},
                     code=409,
                     server=self.n1,
                     url=self.n1.url('api_1_0.locker_unlock'))
        ], e.exception.responses)
Beispiel #4
0
    def test_lock_unlock_unlock(self, m):
        def callback_unlock(url, **kwargs):
            self.assertDictEqual(
                kwargs['json'], {
                    'scope': 'ORCHESTRATION',
                    'applicant': [str(self.n1.id),
                                  str(self.n2.id)]
                })
            return CallbackResult(payload={'message': 'UnLocked'}, status=200)

        m.post(self.n1.url('api_1_0.locker_unlock'), callback=callback_unlock)
        m.post(self.n2.url('api_1_0.locker_unlock'), callback=callback_unlock)

        ret = lock_unlock('U',
                          Scope.ORCHESTRATION, [self.n1, self.n2],
                          identity=ROOT)

        self.assertIsNone(ret)
Beispiel #5
0
    def test_lock_unlock_lock_with_server_error_on_preventing(self, m):
        m.post(self.n1.url('api_1_0.locker_prevent'),
               status=200,
               payload={'message': 'Preventing lock acquired'})
        m.post(self.n2.url('api_1_0.locker_prevent'),
               status=500,
               body="Error message")

        with self.assertRaises(errors.LockError) as e:
            ret = lock_unlock('L',
                              Scope.ORCHESTRATION, [self.n1, self.n2],
                              identity=ROOT)

        self.assertEqual(Scope.ORCHESTRATION, e.exception.scope)
        self.assertListEqual([
            Response("Error message",
                     code=500,
                     server=self.n2,
                     url=self.n2.url('api_1_0.locker_prevent'))
        ], e.exception.responses)
Beispiel #6
0
    def test_lock_unlock_lock_with_connection_error(self, m):
        m.post(self.n1.url('api_1_0.locker_prevent'),
               status=200,
               payload={'message': 'Preventing lock acquired'})
        m.post(self.n2.url('api_1_0.locker_prevent'),
               exception=aiohttp.ClientConnectionError('test'))

        with self.assertRaises(errors.LockError) as e:
            ret = lock_unlock('L',
                              Scope.ORCHESTRATION, [self.n1, self.n2],
                              identity=ROOT)

        self.assertEqual(Scope.ORCHESTRATION, e.exception.scope)
        self.assertEqual(1, len(e.exception.responses))
        response = e.exception.responses[0]
        self.assertIsNone(response.msg)
        self.assertIsNone(response.code)
        self.assertEqual(self.n2, response.server)
        self.assertIsInstance(response.exception,
                              aiohttp.ClientConnectionError)
        self.assertTupleEqual(('test', ), response.exception.args)