Esempio n. 1
0
    def test_set_leaves_multiple_transactions(self):
        """
        This tests setting values- here we can see sysrepo doesn't block a commit
        when the data changes.

        We can see commits don't persist to startup config.

        Importantly though, we can see that after subject1 has changed the value from
        Inside to Outside subject2 on it's following get picks up the new value
        instead of what it was when it created the value.
        """
        xpath = "/integrationtest:morecomplex/inner/leaf5"
        value = "Outside"

        sysrepodal1 = SysrepoDataAbstractionLayer()
        self.subject1 = yangvoodoo.DataAccess(
            disable_proxy=True, data_abstraction_layer=sysrepodal1)
        self.subject.connect('integrationtest', yang_location='yang')
        self.subject1.connect('integrationtest', 'yang', 'a')
        sysrepodal2 = SysrepoDataAbstractionLayer()
        self.subject2 = yangvoodoo.DataAccess(
            disable_proxy=True, data_abstraction_layer=sysrepodal2)
        self.subject2.connect('integrationtest', 'yang', 'b')

        self.subject1.set(xpath, value)
        self.assertEqual(self.subject1.get(xpath), 'Outside')
        self.subject1.commit()
        self.assertEqual(self.subject2.get(xpath), 'Outside')

        value = 'Middle'
        self.subject2.set(xpath, value)
        self.subject2.commit()
        self.assertEqual(self.subject2.get(xpath), 'Middle')
    def setUp(self):
        self.maxDiff = None
        self.stub_a = yangvoodoo.stubdal.StubDataAbstractionLayer()
        self.session_a = yangvoodoo.DataAccess(
            data_abstraction_layer=self.stub_a)
        self.session_a.connect('integrationtest', yang_location='yang')
        self.root_a = self.session_a.get_node()

        self.stub_b = yangvoodoo.stubdal.StubDataAbstractionLayer()
        self.session_b = yangvoodoo.DataAccess(
            data_abstraction_layer=self.stub_b)
        self.session_b.connect('integrationtest', yang_location='yang')
        self.root_b = self.session_b.get_node()
    def test_super_root(self):
        session1 = yangvoodoo.DataAccess(data_abstraction_layer=self.stub)
        session1.connect('integrationtest', yang_location='yang')

        session2 = yangvoodoo.DataAccess(data_abstraction_layer=self.stub)
        session2.connect('integrationtest', yang_location='yang')

        super_root = yangvoodoo.DataAccess.get_root(session1, 'web')
        super_root.attach_node_from_session(session2, 'morecomplex')

        self.assertEqual(dir(super_root), ['morecomplex', 'web'])
        self.assertEqual(repr(super_root.morecomplex),
                         'VoodooContainer{/integrationtest:morecomplex}')
        self.assertEqual(repr(super_root.web),
                         'VoodooContainer{/integrationtest:web}')
Esempio n. 4
0
 def setUp(self):
     self.maxDiff = None
     self.stub = yangvoodoo.stublydal.StubLyDataAbstractionLayer()
     self.subject = yangvoodoo.DataAccess(data_abstraction_layer=self.stub,
                                          disable_proxy=True)
     self.subject.connect('integrationtest', yang_location='yang')
     self.root = self.subject.get_node()
 def setUp(self):
     self.maxDiff = None
     self.stub = yangvoodoo.stubdal.StubDataAbstractionLayer()
     self.session = yangvoodoo.DataAccess(data_abstraction_layer=self.stub, disable_proxy=True)
     self.session.connect('integrationtest')
     self.root = self.session.get_node()
     self.template_ninja = TemplateNinja()
 def setUp(self):
     self.maxDiff = None
     self.subject = yangvoodoo.DataAccess()
     self.subject.connect('integrationtest', yang_location='yang')
     self.subject.add_module('ietf-netconf')
     self.root = self.subject.get_node(readonly=True)
     self.subject.loads(self.BASE_TEMPLATE)
Esempio n. 7
0
    def test_leafref(self):
        xpath = "/integrationtest:thing-that-is-leafref"
        valid_value = 'GHI'
        self.subject.set(xpath, valid_value)
        self.subject.commit()

        xpath = "/integrationtest:thing-that-is-leafref"
        invalid_value = 'ZZZ'
        self.subject.set(xpath, invalid_value)

        with self.assertRaises(
                yangvoodoo.Errors.BackendDatastoreError) as context:
            self.subject.commit()
        self.assertEqual(str(context.exception), (
            "1 Errors occured\n"
            "Error 0: Leafref \"../thing-to-leafref-against\" of value \"ZZZ\" "
            "points to a non-existing leaf. (Path: /integrationtest:thing-that-is-leafref)\n"
        ))

        sysrepodal = SysrepoDataAbstractionLayer()
        self.subject = yangvoodoo.DataAccess(disable_proxy=True,
                                             data_abstraction_layer=sysrepodal)
        self.subject.connect('integrationtest', yang_location='yang')

        xpath = "/integrationtest:thing-that-is-a-list-based-leafref"
        valid_value = 'I'
        self.subject.set(xpath, valid_value)
        self.subject.commit()

        valid_value = 'W'
        self.subject.set(xpath, valid_value)
        self.subject.commit()
Esempio n. 8
0
    def test_connect_avoids_connecting_if_libyang_data_already_exists(self):
        stubly = Mock()
        subject = yangvoodoo.DataAccess(data_abstraction_layer=stubly, disable_proxy=True)
        subject.data_abstraction_layer.libyang_data = stubly
        subject.connect('integrationtest', yang_location='yang')

        self.assertEqual(stubly, subject.data_abstraction_layer.libyang_data)
    def setUp(self):
        self.maxDiff = None

        self.stubly = yangvoodoo.stublydal.StubLyDataAbstractionLayer(
            log_level=2)
        self.subject = yangvoodoo.DataAccess(
            data_abstraction_layer=self.stubly, disable_proxy=True)
        self.subject.connect("integrationtest", yang_location='yang')
        yang_ctx = self.subject.yang_ctx
        self.root = self.subject.get_node()

        self.stubly2 = yangvoodoo.stublydal.StubLyDataAbstractionLayer(
            log_level=2)
        self.subject2 = yangvoodoo.DataAccess(
            data_abstraction_layer=self.stubly2, disable_proxy=True)
        self.subject2.connect('integrationtest',
                              yang_location='yang',
                              yang_ctx=yang_ctx)
        self.root2 = self.subject2.get_node()
Esempio n. 10
0
    def test_set_leaves(self):
        """
        This tests setting leaves with and without commits.

        We can see commits don't persist to startup config.
        """
        xpath = "/integrationtest:morecomplex/inner/leaf5"
        value = "Outside"
        self.subject.set(xpath, value)
        self.assertEqual(self.subject.get(xpath), 'Outside')

        sysrepodal = SysrepoDataAbstractionLayer()
        self.subject = yangvoodoo.DataAccess(disable_proxy=True,
                                             data_abstraction_layer=sysrepodal)
        self.subject.connect('integrationtest', yang_location='yang')

        xpath = "/integrationtest:morecomplex/inner/leaf5"
        self.assertNotEqual(self.subject.get(xpath), 'Outside')

        xpath = "/integrationtest:morecomplex/inner/leaf5"
        value = "Outside"
        self.subject.set(xpath, value)
        self.assertEqual(self.subject.get(xpath), 'Outside')
        self.subject.commit()

        sysrepodal = SysrepoDataAbstractionLayer()
        self.subject = yangvoodoo.DataAccess(disable_proxy=True,
                                             data_abstraction_layer=sysrepodal)
        self.subject.connect('integrationtest', yang_location='yang')

        xpath = "/integrationtest:morecomplex/inner/leaf5"
        self.assertEqual(self.subject.get(xpath), 'Outside')

        xpath = "/integrationtest:morecomplex/inner/leaf5"
        value = "Inside"
        self.subject.set(xpath, value)
        self.subject.commit()
Esempio n. 11
0
    def setUp(self):
        command = 'sysrepocfg --import=init-data/integrationtest.xml --format=xml --datastore=running integrationtest'
        process = subprocess.Popen(["bash"],
                                   stdin=subprocess.PIPE,
                                   stdout=subprocess.PIPE)
        (out, err) = process.communicate(command.encode('UTF-8'))
        if err:
            raise ValueError('Unable to import data\n%s\n%s' % (out, err))

        time.sleep(0.25)

        sysrepodal = SysrepoDataAbstractionLayer()
        self.subject = yangvoodoo.DataAccess(disable_proxy=True,
                                             data_abstraction_layer=sysrepodal)
        self.subject.connect('integrationtest', yang_location='yang')
 def setUp(self):
     self.maxDiff = None
     self.subject = yangvoodoo.DataAccess()