Beispiel #1
0
    def test_multi_controller_path(self):
        csl = ControllerSlice()
        csi = ControllerSite()
        site = Site()
        slice = Slice()
        slice.site = site
        csl.slice = slice
        csi.site = site
        slice.controllerslices = mock_enumerator([csl])
        site.controllersite = mock_enumerator([csi])

        verdict, edge_type = self.synchronizer.concrete_path_exists(csl, csi)
        self.assertTrue(verdict)
    def test_multi_controller_path_negative(self):
        csl = ControllerSlice()
        csi = ControllerSite()
        site = Site()
        slice = Slice()
        slice.site = site
        csl.slice = slice
        csi.site = site
        slice.controllerslices = mock_enumerator([])
        site.controllersite = mock_enumerator([])

        verdict, edge_type = self.synchronizer.concrete_path_exists(csl, csi)
        self.assertFalse(verdict)
        self.assertEqual(edge_type, None)
Beispiel #3
0
    def test_concrete_no_object_path_distant(self):
        p = Instance()
        s = Slice()
        s.controllerslice = mock_enumerator([])

        t = Site()
        t.controllersite = mock_enumerator([])

        ct = ControllerSite()
        ct.site = Site()
        p.slice = s
        s.site = t

        verdict, _ = self.synchronizer.concrete_path_exists(p, ct)
        self.assertFalse(verdict)
    def test_multi_controller_schedule_negative(self):
        csl = ControllerSlice()
        csi = ControllerSite()
        site = Site()
        slice = Slice()
        slice.site = site
        slice.controllerslices = mock_enumerator([])
        site.controllersite = mock_enumerator([])
        i = Instance()
        i.slice = slice

        cohorts = self.synchronizer.compute_dependent_cohorts([i, slice, site, csl, csi], False)
        self.assertIn([site, slice, i], cohorts)
        self.assertIn([csl], cohorts)
        self.assertIn([csi], cohorts)
Beispiel #5
0
    def test_controller_deletion_path(self):
        p = Instance()
        s = Slice()
        t = Site()
        ct = ControllerSite()
        ct.site = t
        p.slice = s
        s.site = t

        t.controllersite = mock_enumerator([ct])

        cohorts = self.synchronizer.compute_dependent_cohorts([p, s, t, ct],
                                                              False)
        self.assertIn(t, cohorts[0])
        self.assertIn(ct, cohorts[0])
        self.assertIn(s, cohorts[0])
        self.assertIn(p, cohorts[0])
        # TODO(smbaker): This assert was found to be failing. Understand whether the library or the test is at fault.
        #self.assertEqual([t, ct, s, p], cohorts[0])

        cohorts = self.synchronizer.compute_dependent_cohorts([p, s, t, ct],
                                                              True)
        self.assertIn(t, cohorts[0])
        self.assertIn(ct, cohorts[0])
        self.assertIn(s, cohorts[0])
        self.assertIn(p, cohorts[0])
Beispiel #6
0
    def DISABLED_test_multi_controller_deletion_schedule(self):
        # TODO(smbaker): `csi` is undefined, test is broken as written.

        csl = ControllerSlice()
        cn = ControllerNetwork()
        site = Site()
        slice = Slice()
        slice.site = site
        slice.controllerslices = mock_enumerator([])
        site.controllersite = mock_enumerator([])
        i = Instance()
        i.slice = slice

        cohorts = self.synchronizer.compute_dependent_cohorts(
            [i, slice, site, csl, csi], False)
        self.assertIn([site, slice, i], cohorts)
        self.assertIn([csl], cohorts)
        self.assertIn([csi], cohorts)
Beispiel #7
0
    def test_concrete_object_controller_path_adjacent(self):
        p = Instance()
        q = Instance()
        cs = ControllerSlice()
        cs2 = ControllerSlice()
        s1 = Slice()
        s2 = Slice()
        p.slice = s1
        q.slice = s2
        cs.slice = s1
        s1.controllerslices = mock_enumerator([cs])
        s2.controllerslices = mock_enumerator([])

        verdict1, edge_type1 = self.synchronizer.concrete_path_exists(p, cs)
        verdict2, _ = self.synchronizer.concrete_path_exists(q, cs)
        verdict3, _ = self.synchronizer.concrete_path_exists(p, cs2)

        self.assertTrue(verdict1)
        self.assertFalse(verdict2)
        self.assertFalse(verdict3)
 def test_controller_path_simple_negative(self):
     p = Instance()
     s = Slice()
     t = Site()
     ct = ControllerSite()
     p.slice = s
     s.site = t
     ct.site = t
     t.controllersite = mock_enumerator([])
     cohorts = self.synchronizer.compute_dependent_cohorts([p, ct], False)
     self.assertIn([ct], cohorts)
     self.assertIn([p], cohorts)
Beispiel #9
0
    def test_same_object_lst_dc(self):
        r = Slice(pk=4)
        s = Slice(pk=5)
        t = ControllerSlice(slice=r)
        u = ControllerSlice(slice=s)

        s.controllerslices = mock_enumerator([u])

        same, et = self.synchronizer.same_object(s.controllerslices, t)
        self.assertFalse(same)

        same, et = self.synchronizer.same_object(s.controllerslices, u)
        self.assertTrue(same)
Beispiel #10
0
    def test_same_object_lst(self):
        s = Slice(pk=5)
        t = ControllerSlice(slice=s)
        u = ControllerSlice(slice=s)

        s.controllerslices = mock_enumerator([t, u])

        same, et = self.synchronizer.same_object(s.controllerslices, u)
        self.assertTrue(same)
        self.assertEqual(et, event_loop.PROXY_EDGE)

        same, et = self.synchronizer.same_object(s.controllerslices, t)

        self.assertTrue(same)
        self.assertEqual(et, event_loop.PROXY_EDGE)
    def test_controller_deletion_path(self):
        p = Instance()
        s = Slice()
        t = Site()
        ct = ControllerSite()
        ct.site = t
        p.slice = s
        s.site = t

        t.controllersite = mock_enumerator([ct])
        
        cohorts = self.synchronizer.compute_dependent_cohorts([p,s,t,ct], False)
        self.assertEqual([t, ct, s, p], cohorts[0])
        cohorts = self.synchronizer.compute_dependent_cohorts([p,s,t,ct], True)
        self.assertEqual([p, s, ct, t], cohorts[0])
    def test_controller_deletion_path_negative(self):
        p = Instance()
        s = Slice()
        t = Site()
        ct = ControllerSite()
        s.site = t

        t.controllersite = mock_enumerator([])
        
        cohorts = self.synchronizer.compute_dependent_cohorts([p,s,t,ct], False)
        self.assertIn([t,s], cohorts)
        self.assertIn([p], cohorts)
        self.assertIn([ct], cohorts)
        cohorts = self.synchronizer.compute_dependent_cohorts([p,s,t,ct], True)
        self.assertIn([s,t], cohorts)
        self.assertIn([p], cohorts)
        self.assertIn([ct], cohorts)
Beispiel #13
0
    def test_cohorting_related_multi(self):
        i = Image()
        p = Port()
        c = Instance()
        c.image = i
        cs = ControllerSlice()
        s = Slice()
        cs.slice = s
        s.controllerslices = mock_enumerator([cs])
        c.slice = s

        cohorts = self.synchronizer.compute_dependent_cohorts([i,p,c,s,cs], False)

        big_cohort = max(cohorts, key=len)
        self.assertGreater(big_cohort.index(c), big_cohort.index(i))
        self.assertGreater(big_cohort.index(cs), big_cohort.index(s))
        self.assertIn([p], cohorts)
Beispiel #14
0
    def test_cohorting_related_multi(self):
        i = Image()
        p = Port()
        c = Instance()
        c.image = i
        cs = ControllerSlice()
        s = Slice()
        cs.slice = s
        s.controllerslices = mock_enumerator([cs])
        c.slice = s

        cohorts = self.synchronizer.compute_dependent_cohorts([i, p, c, s, cs], False)

        big_cohort = max(cohorts, key=len)
        self.assertGreater(big_cohort.index(c), big_cohort.index(i))
        # TODO(smbaker): This assert was found to be failing. Understand whether the library or the test is at fault.
        #self.assertGreater(big_cohort.index(cs), big_cohort.index(s))
        self.assertIn([p], cohorts)