Exemple #1
0
    def test_copy_config(self):
        op = self.netconf_service.copy_config(self.ncc, Datastore.candidate,
                                              Datastore.running)
        self.assertEqual(None, op)

        runner = Runner()
        runner.two.number = 2
        runner.two.name = 'runner:two:name'
        get_filter = Runner()

        op = self.netconf_service.edit_config(self.ncc, Datastore.candidate,
                                              runner)
        self.assertEqual(None, op)

        op = self.netconf_service.copy_config(self.ncc, Datastore.running,
                                              Datastore.candidate)
        self.assertEqual(None, op)

        result = self.netconf_service.get_config(self.ncc, Datastore.running,
                                                 get_filter)
        self.assertEqual(is_equal(result, runner), True)

        runner.two.name += 'modified'

        op = self.netconf_service.copy_config(self.ncc, Datastore.running,
                                              runner)
        self.assertEqual(None, op)

        result = self.netconf_service.get_config(self.ncc, Datastore.running,
                                                 get_filter)
        self.assertEqual(is_equal(result, runner), True)
Exemple #2
0
 def test_twolist_pos(self):
     # READ
     r_1, r_2 = Runner(), Runner()
     e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
     e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
     e_1.number = 21
     e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
     e_11.number = 211
     e_11.name = 'runner:twolist:ldata[' + str(
         e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
     e_12.number = 212
     e_12.name = 'runner:twolist:ldata[' + str(
         e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
     e_1.subl1.extend([e_11, e_12])
     e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
     e_2.number = 22
     e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
     e_21.number = 221
     e_21.name = 'runner:twolist:ldata[' + str(
         e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
     e_22.number = 222
     e_22.name = 'runner:twolist:ldata[' + str(
         e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
     e_2.subl1.extend([e_21, e_22])
     r_1.two_list.ldata.extend([e_1, e_2])
     self.crud.create(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # UPDATE
     r_1, r_2 = Runner(), Runner()
     e_1, e_2 = Runner.TwoList.Ldata(), Runner.TwoList.Ldata()
     e_11, e_12 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
     e_1.number = 21
     e_1.name = 'runner/twolist/ldata[' + str(e_1.number) + ']/name'
     e_11.number = 211
     e_11.name = 'runner/twolist/ldata[' + str(
         e_1.number) + ']/subl1[' + str(e_11.number) + ']/name'
     e_12.number = 212
     e_12.name = 'runner/twolist/ldata[' + str(
         e_1.number) + ']/subl1[' + str(e_12.number) + ']/name'
     e_1.subl1.extend([e_11, e_12])
     e_21, e_22 = Runner.TwoList.Ldata.Subl1(), Runner.TwoList.Ldata.Subl1()
     e_2.number = 22
     e_2.name = 'runner/twolist/ldata[' + str(e_2.number) + ']/name'
     e_21.number = 221
     e_21.name = 'runner/twolist/ldata[' + str(
         e_2.number) + ']/subl1[' + str(e_21.number) + ']/name'
     e_22.number = 222
     e_22.name = 'runner/twolist/ldata[' + str(
         e_2.number) + ']/subl1[' + str(e_22.number) + ']/name'
     e_2.subl1.extend([e_21, e_22])
     r_1.two_list.ldata.extend([e_1, e_2])
     self.crud.update(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # DELETE
     r_1 = Runner()
     self.crud.delete(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_1)
     self.assertEqual(r_2._has_data(), False)
Exemple #3
0
    def test_runner(self):
        runner = Runner()
        runner_meta = runner._meta_info()
        self.assertEqual(runner_meta.module_name, "ydktest-sanity")
        self.assertEqual(runner_meta.name, "Runner")
        self.assertEqual(runner_meta.yang_name, "runner")
        print(runner_meta.name, runner_meta.doc)
        for member_meta in runner_meta.meta_info_class_members:
            print("{}  --  {}".format(member_meta.name, member_meta._doc.strip()))

        one_list_meta = runner_meta.member('one-list')
        self.assertIsNotNone(one_list_meta)
        self.assertEqual(one_list_meta.name, 'one-list')

        built_in_t_meta = runner.ytypes.built_in_t._meta_info()
        embeded_enum_meta = built_in_t_meta.member('embeded-enum')
        self.assertIsNotNone(embeded_enum_meta)
        embeded_enum_map = embeded_enum_meta.enum_dict()
        print("\nEnum dictionary:")
        for name in embeded_enum_map:
            print("%12s: %s" % (name, embeded_enum_map[name]))
        self.assertTrue(len(embeded_enum_map) > 0)
        self.assertEqual(embeded_enum_map['seven'].value, 7)

        test_enum_union_meta()
        test_module_meta()
Exemple #4
0
 def test_onelsit_pos(self):
     # READ
     r_1, r_2 = Runner(), Runner()
     e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
     e_1.number = 1
     e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
     e_2.number = 2
     e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
     r_1.one_list.ldata.extend([e_1, e_2])
     self.crud.create(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # UPDATE
     r_1, r_2 = Runner(), Runner()
     e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
     e_1.number = 1
     e_1.name = 'runner:onelist:ldata[' + str(e_1.number) + ']:name'
     e_2.number = 2
     e_2.name = 'runner:onelist:ldata[' + str(e_2.number) + ']:name'
     r_1.one_list.ldata.extend([e_1, e_2])
     self.crud.update(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # DELETE
     r_1 = Runner()
     self.crud.delete(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_1)
     self.assertEqual(r_2._has_data(), False)
Exemple #5
0
    def test_replace_on_container(self):
        one = Runner.One()
        one.number, one.name = 1, 'runner-one-name'
        self.crud.create(self.ncc, one)

        filter = Runner.One()
        r = self.crud.read(self.ncc, filter)
        self.assertEqual(one.number, r.number)

        # Replace container value and verify
        one.yfilter = REPLACE()
        one.name = 'runner_one_name'
        one.number = 2
        self.crud.update(self.ncc, one)

        r = self.crud.read(self.ncc, filter)
        self.assertEqual(r.name, 'runner_one_name')
        self.assertEqual(r.number, 2)

        one.yfilter = REMOVE()
        self.crud.update(self.ncc, one)

        r = self.crud.read(self.ncc, Runner.One())
        self.assertIsNone(r.name)
        self.assertIsNone(r.number)
Exemple #6
0
    def test_replace_on_list(self):
        one_list = Runner.OneList()
        ld1, ld2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
        ld1.number, ld2.number = 1, 2
        one_list.ldata.extend([ld1, ld2])
        self.crud.create(self.ncc, one_list)

        filter = Runner.OneList.Ldata()
        filter.number = 2
        r = self.crud.read(self.ncc, filter)
        self.assertTrue(is_equal(r, ld2))

        # Merge and Verify
        one_merge = Runner.OneList()
        ld3 = Runner.OneList.Ldata()
        ld3.number = 3
        one_merge.ldata.append(ld3)

        one_merge.yfilter = MERGE()
        self.crud.update(self.ncc, one_merge)

        r = self.crud.read(self.ncc, Runner.OneList())
        self.assertEqual(len(r.ldata), 3)

        # Replace and Verify
        replace = Runner.OneList()
        replace.ldata.append(ld3)
        replace.yfilter = REPLACE()
        self.crud.update(self.ncc, replace)

        r = self.crud.read(self.ncc, Runner.OneList())
        self.assertEqual(len(r.ldata), 1)
    def test_three_level_pos(self):
        # READ
        r_1 = self._create_runner()
        r_1.three.number, r_1.three.name, \
            r_1.three.sub1.number, r_1.three.sub1.sub2.number = 3, 'runner:three:name', 31, 311
        self.crud.create(self.ncc, r_1)
        r_2 = Runner()
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # UPDATE
        r_1, r_2 = Runner(), Runner()
        r_1.three.number, r_1.three.name, \
            r_1.three.sub1.number, r_1.three.sub1.sub2.number = 30, 'runner/three/name', 310, 3110
        self.crud.update(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # DELETE
        r_1 = Runner()
        self.crud.delete(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_1)

        self.assertEqual(r_2, None)
    def test_leafref_simple_pos(self):
        # change ref and original data together
        # READ
        r_1, r_2 = Runner(), Runner()
        r_1.ytypes.built_in_t.number8 = 100
        r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
        self.crud.create(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # UPDATE
        r_1, r_2 = Runner(), Runner()
        r_1.ytypes.built_in_t.number8 = 110
        r_1.ytypes.built_in_t.leaf_ref = r_1.ytypes.built_in_t.number8
        self.crud.update(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # DELETE
        r_1 = Runner()
        self.crud.delete(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_1)

        self.assertEqual(r_2, None)
    def test_aug_one_pos(self):
        # CREATE
        r_1, r_2 = Runner(), Runner()
        r_1.ydktest_sanity_one.one_aug.number = 1
        r_1.ydktest_sanity_one.one_aug.name = "r_1.ydktest_sanity_one.one_aug.name"
        self.crud.create(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # UPDATE
        r_1, r_2 = Runner(), Runner()
        r_1.ydktest_sanity_one.one_aug.number = 10
        r_1.ydktest_sanity_one.one_aug.name = "r_1.ydktest_sanity_one.one_aug.name".replace(
            '.', ':')
        self.crud.update(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_2)

        self.assertEqual(r_1, r_2)

        # DELETE
        r_1 = Runner()
        self.crud.delete(self.ncc, r_1)
        r_2 = self.crud.read(self.ncc, r_1)

        self.assertEqual(r_2, None)
Exemple #10
0
    def test_inner_pres(self):
        runner = Runner()
        runner.outer.inner = runner.Outer.Inner()
        self.crud.create(self.ncc, runner)

        runner_read = self.crud.read(self.ncc, Runner())
        self.assertEqual(runner, runner_read)
    def test_identity_leaflist(self):
        runner = self._create_runner()
        runner.ytypes.built_in_t.identity_llist.append(ChildIdentityIdentity())
        runner.ytypes.built_in_t.identity_llist.append(
            ChildChildIdentityIdentity())
        self.crud.create(self.ncc, runner)

        # Read into Runner2
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        result = is_equal(runner, runner1)
        self.assertEqual(result, True)

        #DEEPCOPY
        runner_copy = copy.deepcopy(runner)
        # result = is_equal(runner, runner_copy)
        # self.assertEqual(result, True)

        self.crud.delete(self.ncc, Runner())
        self.crud.create(self.ncc, runner_copy)

        # Read into Runner2
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        result = is_equal(runner, runner1)
        self.assertEqual(result, True)
Exemple #12
0
 def test_aug_onelist_pos(self):
     # CREATE
     r_1, r_2 = Runner(), Runner()
     e_1 = Runner.OneList.OneAugList.Ldata()
     e_2 = Runner.OneList.OneAugList.Ldata()
     e_1.number = 1
     e_1.name = e_1._common_path
     e_2.number = 2
     e_2.name = e_2._common_path
     r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
     r_1.one_list.one_aug_list.enabled = True
     self.crud.create(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # UPDATE
     r_1, r_2 = Runner(), Runner()
     e_1 = Runner.OneList.OneAugList.Ldata()
     e_2 = Runner.OneList.OneAugList.Ldata()
     e_1.number = 1
     e_1.name = e_1._common_path.replace(':', '/')
     e_2.number = 2
     e_2.name = e_2._common_path.replace(':', '/')
     r_1.one_list.one_aug_list.ldata.extend([e_1, e_2])
     r_1.one_list.one_aug_list.enabled = True
     self.crud.update(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(is_equal(r_1, r_2), True)
     # DELETE
     r_1 = Runner()
     self.crud.delete(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
     self.assertEqual(r_2._has_data(), False)
Exemple #13
0
    def test_read_on_ref_class(self):
        r_1 = Runner()
        r_1.one.number, r_1.one.name = 1, 'runner:one:name'
        self.crud.create(self.ncc, r_1)
        r_2 = Runner()

        r_2.one = READ()
        r_2 = self.crud.read(self.ncc, r_2)
        self.assertEqual(is_equal(r_1, r_2), True)
Exemple #14
0
    def test_embedded_double_quote_list_key(self):
        r = Runner()
        t = Runner.TwoKeyList()
        t.first = 'ab"c'
        t.second = 1233
        r.two_key_list.append(t)
        self.crud.create(self.ncc, r)

        runner_read = self.crud.read(self.ncc, Runner())
        self.assertEqual(r, runner_read)
Exemple #15
0
    def test_embedded_slash_list_key(self):
        r = Runner()
        t = Runner.TwoKeyList()
        t.first = "ab/c"
        t.second = 1233
        r.two_key_list.append(t)
        self.crud.create(self.ncc, r)

        runner_read = self.crud.read(self.ncc, Runner())
        self.assertEqual(r, runner_read)
Exemple #16
0
    def test_parent_empty(self):
        runner = Runner()
        runner.ytypes.enabled = Empty()
        runner.ytypes.built_in_t.emptee = Empty()

        self.crud.create(self.ncc, runner)

        runner_read = self.crud.read(self.ncc, Runner())

        self.assertEqual(runner, runner_read)
    def embedded_single_quote_list_key(self):
        r = Runner()
        t = Runner.TwoKeyList()
        t.first = "ab\'c"
        t.second = 1233
        r.two_key_list.append(t)
        self.crud.create(self.ncc, runner)

        runner_read = self.crud.read(self.ncc, Runner())
        self.assertEqual(runner, runner_read)
Exemple #18
0
 def test_mand(self):
     # READ
     r_1 = Runner()
     mand = r_1.MandList()
     mand.name = 'test'
     mand.num = 20
     r_1.mand_list.append(mand)
     payload = self.codec.encode(self.provider, r_1)
     entity = self.codec.decode(self.provider, payload)
     self.assertEqual(is_equal(r_1, entity), True)
     self.assertEqual(payload, self.codec.encode(self.provider, entity))
Exemple #19
0
    def test_empty(self):
        runner = Runner()
        runner.ytypes.built_in_t.emptee = Empty()
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #20
0
    def test_embedded_enum(self):
        runner = Runner()
        runner.ytypes.built_in_t.embeded_enum = Runner.Ytypes.BuiltInT.EmbededEnum.zero
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #21
0
    def test_union(self):
        runner = Runner()
        runner.ytypes.built_in_t.younion = YdkEnumTest.none
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #22
0
 def test_onelist_neg_dupkey(self):
     # netsim/enxr not complaining
     r_1, r_2 = Runner(), Runner()
     e_1, e_2 = Runner.OneList.Ldata(), Runner.OneList.Ldata()
     e_1.number = 1
     e_2.name = 'foo'
     e_2.number = 1
     e_2.name = 'bar'
     r_1.one_list.ldata.extend([e_1, e_2])
     self.crud.create(self.ncc, r_1)
     r_2 = self.crud.read(self.ncc, r_2)
Exemple #23
0
    def test_union_int(self):
        runner = Runner()
        runner.ytypes.built_in_t.enum_int_value = 2
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #24
0
    def test_union_recursive(self):
        runner = Runner()
        runner.ytypes.built_in_t.younion_recursive = 18
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #25
0
    def test_union_complex_list(self):
        runner = Runner()
        runner.ytypes.built_in_t.younion_list.append("123:45")
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #26
0
    def test_status_enum(self):
        runner = Runner()
        runner.ytypes.built_in_t.status = runner.ytypes.built_in_t.Status.not_connected
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #27
0
    def test_read_only_config(self):
        r_1 = Runner()
        r_1.one.number, r_1.one.name = 1, 'runner:one:name'
        self.crud.create(self.ncc, r_1)
        r_2, r_3 = Runner(), Runner()
        r_2.one.number, r_3.one.number = READ(), READ()

        r_2 = self.crud.read(self.ncc, r_2, only_config=True)
        r_3 = self.crud.read(self.ncc, r_3)
        # ysanity only have config data, ok to compare
        self.assertEqual(is_equal(r_2, r_3), True)
Exemple #28
0
    def test_string_1(self):
        runner = Runner()
        runner.ytypes.built_in_t.name = 'name_str'
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #29
0
    def test_int16(self):
        runner = Runner()
        runner.ytypes.built_in_t.number16 = 126
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #30
0
    def test_decimal64(self):
        runner = Runner()
        runner.ytypes.built_in_t.deci64 = Decimal64('3.14')
        self.crud.create(self.ncc, runner)

        # Read into Runner1
        runner1 = Runner()
        runner1 = self.crud.read(self.ncc, runner1)

        # Compare runners
        self.assertEqual(runner, runner1)
Exemple #31
0
    def test_runner(self):
        runner = Runner()
        runner_meta = runner._meta_info()
        self.assertEqual(runner_meta.module_name, "ydktest-sanity")
        self.assertEqual(runner_meta.name, "Runner")
        self.assertEqual(runner_meta.yang_name, "runner")
        print(runner_meta.name, runner_meta.doc)
        for member_meta in runner_meta.meta_info_class_members:
            print("{}  --  {}".format(member_meta.name, member_meta._doc.strip()))

        one_list_meta = runner_meta.member('one-list')
        self.assertIsNotNone(one_list_meta)
        self.assertEqual(one_list_meta.name, 'one-list')

        built_in_t_meta = runner.ytypes.built_in_t._meta_info()
        embeded_enum_meta = built_in_t_meta.member('embeded-enum')
        self.assertIsNotNone(embeded_enum_meta)

        embeded_enum_map = embeded_enum_meta.enum_dict()
        print("\nEnum dictionary:\n    %s" % embeded_enum_map)
        self.assertTrue(len(embeded_enum_map) > 0)
        self.assertEqual(embeded_enum_map['seven'].value, 7)