How to use disable_namespace method in avocado

Best Python code snippet using avocado_python

ndctl.py

Source:ndctl.py

...305        self.plib.enable_region()306        regions = self.plib.run_ndctl_list('-R')307        for val in regions:308            region = self.plib.run_ndctl_list_val(val, 'dev')309            self.plib.disable_namespace(region=region)310            self.plib.destroy_namespace(region=region)311            self.plib.create_namespace(region=region)312            self.check_namespace_align(region)313        namespaces = self.plib.run_ndctl_list('-N')314        self.log.info('Created namespace %s', namespaces)315    @avocado.fail_on(pmem.PMemException)316    def test_namespace_unaligned(self):317        """318        Test namespace319        """320        self.plib.enable_region()321        # Use an default unaligned pagesize and make sure it fails322        align_size = memory.get_page_size()323        size = (64 * 1024 * 1024) + align_size324        regions = self.plib.run_ndctl_list('-R')325        for val in regions:326            region = self.plib.run_ndctl_list_val(val, 'dev')327            self.plib.disable_namespace(region=region)328            self.plib.destroy_namespace(region=region)329            try:330                self.plib.create_namespace(331                    region=region, size=size, align=align_size)332            except pmem.PMemException:333                self.log.info("Unaligned namespace creation failed"334                              "as expected")335            else:336                self.fail("Unaligned namespace creation must have failed! ")337    @avocado.fail_on(pmem.PMemException)338    def test_disable_enable_ns(self):339        """340        Test enable disable namespace341        """342        region = self.get_default_region()343        if (not self.plib.is_region_legacy(region)):344            size = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(345                '-r %s' % region)[0], 'size')346            if size < (3 * 64 * 1024 * 1024):347                self.cancel('Not enough memory to create namespaces')348            for _ in range(0, 3):349                self.plib.create_namespace(region=region, size='64M')350        namespaces = self.plib.run_ndctl_list('-N')351        ns_names = []352        for ns in namespaces:353            ns_names.append(self.plib.run_ndctl_list_val(ns, 'dev'))354        ns_names.append('all')355        for namespace in ns_names:356            self.plib.disable_namespace(namespace=namespace)357            self.plib.enable_namespace(namespace=namespace)358    @avocado.fail_on(pmem.PMemException)359    def test_namespace_modes(self):360        """361        Create  different namespace types362        """363        failed_modes = []364        region = self.get_default_region()365        self.log.info("Using %s for different namespace modes", region)366        self.plib.disable_namespace(region=region)367        self.plib.destroy_namespace(region=region)368        for mode in self.modes:369            self.plib.create_namespace(region=region, mode=mode)370            ns_json = self.plib.run_ndctl_list('-r %s -N' % region)[0]371            created_mode = self.plib.run_ndctl_list_val(ns_json, 'mode')372            if mode != created_mode:373                failed_modes.append(mode)374                self.log.error("Expected mode %s, Got %s", mode, created_mode)375            else:376                self.log.info("Namespace with %s mode: %s", mode, ns_json)377            ns_name = self.plib.run_ndctl_list_val(ns_json, 'dev')378            self.plib.disable_namespace(namespace=ns_name, region=region)379            self.plib.destroy_namespace(namespace=ns_name, region=region)380        if failed_modes:381            self.fail("Namespace for %s mode failed!" % failed_modes)382    @avocado.fail_on(pmem.PMemException)383    def test_namespace_devmap(self):384        """385        Test metadata device mapping option with a namespace386        """387        region = self.get_default_region()388        m_map = self.params.get('map', default='mem')389        self.log.info("Using %s for checking device mapping", region)390        self.plib.disable_namespace(region=region)391        self.plib.destroy_namespace(region=region)392        self.plib.create_namespace(region=region, mode=self.mode_to_use,393                                   memmap=m_map)394        self.log.info("Validating device mapping")395        map_val = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(396            '-r %s -N' % region)[0], 'map')397        if map_val != m_map:398            self.fail("Expected map:%s, Got %s" % (m_map, map_val))399        else:400            self.log.info("Metadata mapped as expected")401    def multiple_namespaces_region(self, region):402        """403        Test multiple namespace with single region404        """405        namespace_size = self.params.get('size', default=None)406        size_align = self.get_size_alignval()407        slot_count = self.plib.get_slot_count(region)408        self.log.info("Using %s for muliple namespace regions", region)409        self.plib.disable_namespace(region=region)410        self.plib.destroy_namespace(region=region)411        if namespace_size and ((namespace_size % size_align) != 0):412            self.cancel("Size value not %d aligned %d \n",413                        size_align, namespace_size)414        region_size = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(415            '-r %s' % region)[0], 'size')416        if not namespace_size:417            namespace_size = region_size // slot_count418            # Now align the namespace size419            namespace_size = (namespace_size // size_align) * size_align420        else:421            slot_count = region_size // namespace_size422        if namespace_size <= size_align:423            self.log.warn("Ns size equal to pagesize, hence skipping region")424            return425        self.log.info("Creating %s namespaces", slot_count)426        for count in range(0, slot_count):427            self.plib.create_namespace(428                region=region, mode=self.mode_to_use, size=namespace_size)429            self.log.info("Namespace %s created", count + 1)430    @avocado.fail_on(pmem.PMemException)431    def test_multiple_namespaces_region(self):432        """433        Test multiple namespace with single region434        """435        region = self.get_default_region()436        if (self.plib.is_region_legacy(region)):437            self.cancel("Legacy config skipping the test")438        self.multiple_namespaces_region(region)439        self.check_namespace_align(region)440    @avocado.fail_on(pmem.PMemException)441    def test_multiple_ns_multiple_region(self):442        """443        Test multiple namespace with multiple region444        """445        self.plib.enable_region()446        if len(self.plib.run_ndctl_list('-R')) <= 1:447            self.cancel("Test not applicable without multiple regions")448        regions = self.plib.run_ndctl_list('-R')449        self.plib.disable_namespace()450        self.plib.destroy_namespace()451        for val in regions:452            region = self.plib.run_ndctl_list_val(val, 'dev')453            if (self.plib.is_region_legacy(region)):454                self.cancel("Legacy config skipping the test")455            self.multiple_namespaces_region(region)456            self.check_namespace_align(region)457    @avocado.fail_on(pmem.PMemException)458    def test_multiple_ns_modes_region(self):459        """460        Test multiple namespace modes with single region461        """462        region = self.get_default_region()463        if (self.plib.is_region_legacy(region)):464            self.cancel("Legacy config skipping the test")465        self.log.info("Using %s for muliple namespace regions", region)466        self.plib.disable_namespace(region=region)467        self.plib.destroy_namespace(region=region)468        size = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(469            '-r %s' % region)[0], 'size')470        if size < (len(self.modes) * 64 * 1024 * 1024):471            self.cancel('Not enough memory to create namespaces')472        for mode in self.modes:473            self.plib.create_namespace(474                region=region, mode=mode, size='64M')475            self.log.info("Namespace of type %s created", mode)476    @avocado.fail_on(pmem.PMemException)477    def test_nslot_namespace(self):478        """479        Test max namespace with nslot value480        """481        region = self.get_default_region()482        if (self.plib.is_region_legacy(region)):483            self.cancel("Legacy config skipping the test")484        size_align = self.get_size_alignval()485        slot_count = self.plib.get_slot_count(region)486        self.log.info("Using %s for max namespace creation", region)487        self.plib.disable_namespace()488        self.plib.destroy_namespace()489        region_size = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(490            '-r %s' % region)[0], 'size')491        namespace_size = region_size // slot_count492        # Now align the namespace size493        namespace_size = (namespace_size // size_align) * size_align494        self.log.info("Creating %s namespace", slot_count)495        for count in range(0, slot_count):496            self.plib.create_namespace(region=region, mode='fsdax',497                                       size=namespace_size)498            self.log.info("Namespace %s created", count)499        self.check_namespace_align(region)500    @avocado.fail_on(pmem.PMemException)501    def test_namespace_reconfigure(self):502        """503        Test namespace reconfiguration504        """505        region = self.get_default_region()506        self.log.info("Using %s for reconfiguring namespace", region)507        self.plib.disable_namespace()508        self.plib.destroy_namespace()509        self.plib.create_namespace(region=region, mode='fsdax', align='64k')510        old_ns = self.plib.run_ndctl_list()[0]511        old_ns_dev = self.plib.run_ndctl_list_val(old_ns, 'dev')512        self.log.info("Re-configuring namespace %s", old_ns_dev)513        self.plib.create_namespace(region=region, mode='fsdax', name='test_ns',514                                   reconfig=old_ns_dev, force=True)515        new_ns = self.plib.run_ndctl_list()[0]516        self.log.info("Checking namespace changes")517        failed_vals = []518        for key, val in new_ns.items():519            if key in list(set(old_ns.keys()) - set(['uuid', 'dev'])):520                if old_ns[key] != val:521                    failed_vals.append({key: val})522            else:523                self.log.info("Newly added filed %s:%s", key, val)524        if failed_vals:525            self.fail("New namespace unexpected change(s): %s" % failed_vals)526    @avocado.fail_on(pmem.PMemException)527    def test_check_namespace(self):528        """529        Verify metadata for sector mode namespaces530        """531        region = self.get_default_region()532        self.plib.disable_namespace()533        self.plib.destroy_namespace()534        self.log.info("Creating sector namespace using %s", region)535        self.plib.create_namespace(region=region, mode='sector')536        ns_sec_dev = self.plib.run_ndctl_list_val(537            self.plib.run_ndctl_list()[0], 'dev')538        self.plib.disable_namespace(namespace=ns_sec_dev)539        self.log.info("Checking BTT metadata")540        if process.system("%s check-namespace %s" % (self.ndctl, ns_sec_dev),541                          ignore_status=True):542            self.fail("Failed to check namespace metadata")543    @avocado.fail_on(pmem.PMemException)544    def test_check_numa(self):545        self.plib.enable_region()546        regions = self.plib.run_ndctl_list('-R')547        if not os.path.exists('/sys/bus/nd/devices/region0/numa_node'):548            self.fail("Numa node entries not found!")549        for val in regions:550            reg = self.plib.run_ndctl_list_val(val, 'dev')551            numa = genio.read_one_line(552                '/sys/bus/nd/devices/%s/numa_node' % reg)553            # Check numa config in ndctl and sys interface554            if len(self.plib.run_ndctl_list('-r %s -R -U %s'555                                            % (reg, numa))) != 1:556                self.fail('Region mismatch between ndctl and sys interface')557    @avocado.fail_on(pmem.PMemException)558    def test_check_ns_numa(self):559        self.plib.enable_region()560        regions = self.plib.run_ndctl_list('-R')561        for dev in regions:562            region = self.plib.run_ndctl_list_val(dev, 'dev')563            if not self.plib.is_region_legacy(region):564                self.plib.disable_namespace(region=region)565                self.plib.destroy_namespace(region=region)566                size = self.plib.run_ndctl_list_val(dev, 'size')567                if size < (3 * 64 * 1024 * 1024):568                    self.log.warn('Skipping region due to insufficient memory')569                    continue570                for _ in range(3):571                    self.plib.create_namespace(572                        region=region, mode='fsdax', size='64M')573            namespaces = self.plib.run_ndctl_list('-N -r %s' % region)574            if not os.path.exists(575                    '/sys/bus/nd/devices/namespace0.0/numa_node'):576                self.fail("Numa node entries not found!")577            for val in namespaces:578                ns_name = self.plib.run_ndctl_list_val(val, 'dev')579                numa = genio.read_one_line(580                    '/sys/bus/nd/devices/%s/numa_node' % ns_name)581                # Check numa config in ndctl and sys interface582                if len(self.plib.run_ndctl_list('-N -n %s -U %s'583                                                % (ns_name, numa))) != 1:584                    self.fail('Numa mismatch between ndctl and sys interface')585    @avocado.fail_on(pmem.PMemException)586    def test_label_read_write(self):587        region = self.get_default_region()588        if (self.plib.is_region_legacy(region)):589            self.cancel("Legacy config skipping the test")590        nmem = "nmem%s" % re.findall(r'\d+', region)[0]591        self.log.info("Using %s for testing labels", region)592        self.plib.disable_region(name=region)593        self.log.info("Filling zeros to start test")594        if process.system('%s zero-labels %s'595                          % (self.ndctl, nmem), shell=True):596            self.fail("Label zero-fill failed")597        self.plib.enable_region(name=region)598        self.plib.create_namespace(region=region)599        self.log.info("Storing labels with a namespace")600        old_op = process.system_output(601            '%s check-labels %s' % (self.ndctl, nmem), shell=True)602        if process.system('%s read-labels %s -o output'603                          % (self.ndctl, nmem), shell=True):604            self.fail("Label read failed")605        self.log.info("Refilling zeroes before a restore")606        self.plib.disable_namespace(region=region)607        self.plib.destroy_namespace(region=region)608        self.plib.disable_region(name=region)609        if process.system('%s zero-labels %s'610                          % (self.ndctl, nmem), shell=True):611            self.fail("Label zero-fill failed after read")612        self.log.info("Re-storing labels with a namespace")613        if process.system('%s write-labels %s -i output'614                          % (self.ndctl, nmem), shell=True):615            self.fail("Label write failed")616        self.plib.enable_region(name=region)617        self.log.info("Checking mismatch after restore")618        new_op = process.system_output(619            '%s check-labels %s' % (self.ndctl, nmem), shell=True)620        if new_op != old_op:621            self.fail("Label read and write mismatch")622        self.log.info("Checking created namespace after restore")623        if len(self.plib.run_ndctl_list('-N -r %s' % region)) != 1:624            self.fail("Created namespace not found after label restore")625    @avocado.fail_on(pmem.PMemException)626    def test_daxctl_list(self):627        """628        Test daxctl list629        """630        region = self.get_default_region()631        self.plib.disable_namespace(region=region)632        self.plib.destroy_namespace(region=region)633        self.plib.create_namespace(region=region, mode='devdax')634        index = re.findall(r'\d+', region)[0]635        vals = self.plib.run_daxctl_list('-r %s' % (index))636        if len(vals) != 1:637            self.fail('Failed daxctl list')638        self.log.info('Created dax device %s', vals)639    @avocado.fail_on(pmem.PMemException)640    def test_region_capabilities(self):641        """642        Test region capabilities643        """644        self.plib.enable_region()645        self.plib.disable_namespace()646        self.plib.destroy_namespace()647        regions = self.plib.run_ndctl_list('-R -C')648        for region in regions:649            cap = self.plib.run_ndctl_list_val(region, 'capabilities')650            sec_sizes = []651            fsdax_align = []652            devdax_align = []653            for typ in cap:654                mode = self.plib.run_ndctl_list_val(typ, 'mode')655                if mode == 'fsdax':656                    fsdax_align = self.plib.run_ndctl_list_val(657                        typ, 'alignments')658                elif mode == 'devdax':659                    devdax_align = self.plib.run_ndctl_list_val(660                        typ, 'alignments')661                elif mode == 'sector':662                    sec_sizes = self.plib.run_ndctl_list_val(663                        typ, 'sector_sizes')664            reg_name = self.plib.run_ndctl_list_val(region, 'dev')665            self.log.info("Creating namespaces with possible sizes")666            for size in sec_sizes:667                self.plib.create_namespace(668                    region=reg_name, mode='sector', sector_size=size)669                self.plib.destroy_namespace(region=reg_name, force=True)670            for size in fsdax_align:671                self.plib.create_namespace(672                    region=reg_name, mode='fsdax', align=size)673                self.plib.destroy_namespace(region=reg_name, force=True)674            for size in devdax_align:675                self.plib.create_namespace(676                    region=reg_name, mode='devdax', align=size)677                self.plib.destroy_namespace(region=reg_name, force=True)678    @avocado.fail_on(pmem.PMemException)679    def test_daxctl_memhotplug_unplug(self):680        """681        Test devdax memory hotplug/unplug682        """683        for cmd in ["reconfigure-device", "offline-memory", "online-memory"]:684            if not self.plib.check_daxctl_subcmd(cmd):685                self.cancel("Binary does not support %s" % cmd)686        region = self.get_default_region()687        self.plib.disable_namespace(region=region)688        self.plib.destroy_namespace(region=region)689        self.plib.create_namespace(region=region, mode='devdax')690        daxdev = self.plib.run_ndctl_list_val(691            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'chardev')692        old_mem = memory.meminfo.MemTotal.b693        dev_prop = self.plib.reconfigure_dax_device(daxdev, mode="system-ram")694        self.log.info("Reconfigured device %s", dev_prop)695        new_mem = memory.meminfo.MemTotal.b696        self.log.info("Memory Before:%s, Memory After:%s", old_mem, new_mem)697        if new_mem <= old_mem:698            self.log.warn("Memorysize not increased %s<=%s", new_mem, old_mem)699        self.plib.set_dax_memory_offline(daxdev)700        unplug_mem = memory.meminfo.MemTotal.b701        if unplug_mem != old_mem:702            self.fail("Memory after unplug is not same as system memory")703        self.log.info("Memory restored to base memory after unplug")704        self.plib.set_dax_memory_online(daxdev)705        hplug_mem = memory.meminfo.MemTotal.b706        if hplug_mem != new_mem:707            self.fail("Memory after hotplug is not same as device size memory")708        self.log.info("Memory hotplug successful with pmem device")709        self.log.info("Restoring pmem device in devdax mode")710        self.plib.set_dax_memory_offline(daxdev)711        self.plib.reconfigure_dax_device(daxdev, mode="devdax")712    @avocado.fail_on(pmem.PMemException)713    def write_read_infoblock(self, ns_name, align='', size=''):714        """715        Write_infoblock on given namespace716        """717        self.plib.write_infoblock(namespace=ns_name, align=align,718                                  size=size, mode='devdax')719        read_out = self.plib.read_infoblock(namespace=ns_name)720        if align:721            if align != int(self.plib.run_ndctl_list_val722                            (read_out[0], 'align')):723                self.fail("Alignment has not changed")724        return read_out[0]725    @avocado.fail_on(pmem.PMemException)726    def test_write_infoblock_supported_align(self):727        """728        Test write_infoblock with align size729        """730        if not self.plib.check_ndctl_subcmd("write-infoblock"):731            self.cancel("Binary does not support write-infoblock")732        region = self.get_default_region()733        self.plib.disable_namespace(region=region)734        self.plib.destroy_namespace(region=region)735        self.plib.create_namespace(region=region, mode='devdax')736        ns_name = self.plib.run_ndctl_list_val(737            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')738        self.plib.disable_namespace(namespace=ns_name)739        map_align = memory.get_supported_huge_pages_size()[0] * 1024740        self.write_read_infoblock(ns_name, align=map_align)741        self.plib.enable_namespace(namespace=ns_name)742    @avocado.fail_on(pmem.PMemException)743    def test_write_infoblock_unalign(self):744        """745        Test write_infoblock with unsupported align size746        """747        if not self.plib.check_ndctl_subcmd("write-infoblock"):748            self.cancel("Binary does not support write-infoblock")749        region = self.get_default_region()750        self.plib.disable_namespace(region=region)751        self.plib.destroy_namespace(region=region)752        self.plib.create_namespace(region=region, mode='devdax')753        ns_name = self.plib.run_ndctl_list_val(754            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')755        self.plib.disable_namespace(namespace=ns_name)756        map_align = memory.get_supported_huge_pages_size()[0] * 1024757        self.write_read_infoblock(758            ns_name, align=self.get_unsupported_alignval(map_align))759        try:760            self.plib.enable_namespace(namespace=ns_name)761        except pmem.PMemException:762            self.log.info("Failed as expected")763        else:764            self.log.info(self.plib.run_ndctl_list())765            self.fail("Enabling namespace must have failed")766        idle_ns = self.plib.run_ndctl_list('-Ni -r %s' % region)767        if len(idle_ns) > 1:768            found = False769            for namespace in idle_ns:770                if int(self.plib.run_ndctl_list_val(namespace, 'size')) != 0:771                    found = True772                    break773        else:774            self.fail("Created namespace is not found")775        if not found:776            self.fail("Namespace with infoblock written not found")777        self.plib.destroy_namespace(namespace=ns_name, force=True)778    @avocado.fail_on(pmem.PMemException)779    def test_write_infoblock_align_default(self):780        """781        Test write_infoblock with align size782        """783        if not self.plib.check_ndctl_subcmd("write-infoblock"):784            self.cancel("Binary does not support write-infoblock")785        region = self.get_default_region()786        self.plib.disable_namespace(region=region)787        self.plib.destroy_namespace(region=region)788        self.plib.create_namespace(region=region, mode='devdax')789        ns_name = self.plib.run_ndctl_list_val(790            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')791        align = self.plib.run_ndctl_list_val(792            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'align')793        self.plib.disable_namespace(namespace=ns_name)794        write_block = self.write_read_infoblock(ns_name)795        if align != self.plib.run_ndctl_list_val(write_block, 'align'):796            self.fail("Alignment is not same as default alignment")797    @avocado.fail_on(pmem.PMemException)798    def test_write_infoblock_size(self):799        """800        Test write_infoblock with align size801        """802        if not self.plib.check_ndctl_subcmd("write-infoblock"):803            self.cancel("Binary does not support write-infoblock")804        region = self.get_default_region()805        self.plib.disable_namespace(region=region)806        self.plib.destroy_namespace(region=region)807        self.plib.create_namespace(region=region, mode='devdax')808        ns_name = self.plib.run_ndctl_list_val(809            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')810        size = self.plib.run_ndctl_list_val(811            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')812        self.plib.disable_namespace(namespace=ns_name)813        align = self.get_size_alignval()814        size = size - align815        self.write_read_infoblock(ns_name, size=size)816        self.plib.enable_namespace(namespace=ns_name)817    @avocado.fail_on(pmem.PMemException)818    def test_write_infoblock_size_unaligned(self):819        """820        Test write_infoblock with align size821        """822        if not self.plib.check_ndctl_subcmd("write-infoblock"):823            self.cancel("Binary does not support write-infoblock")824        region = self.get_default_region()825        self.plib.disable_namespace(region=region)826        self.plib.destroy_namespace(region=region)827        self.plib.create_namespace(region=region, mode='devdax')828        ns_name = self.plib.run_ndctl_list_val(829            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'dev')830        size = self.plib.run_ndctl_list_val(831            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'size')832        self.plib.disable_namespace(namespace=ns_name)833        align = memory.get_page_size()834        size = size - align835        self.write_read_infoblock(ns_name, size=size, align=align)836        try:837            self.plib.enable_namespace(namespace=ns_name)838        except pmem.PMemException:839            self.log.info("Failed as expected")840        else:841            self.log.info(self.plib.run_ndctl_list())842            self.fail("Enabling namespace must have failed")843    @avocado.fail_on(pmem.PMemException)844    def test_sector_write(self):845        """846        Test write on a sector mode device847        """848        region = self.get_default_region()849        self.plib.disable_namespace(region=region)850        self.plib.destroy_namespace(region=region)851        self.plib.create_namespace(region=region, mode='sector',852                                   sector_size='512')853        self.disk = '/dev/%s' % self.plib.run_ndctl_list_val(854            self.plib.run_ndctl_list("-N -r %s" % region)[0], 'blockdev')855        size = self.plib.run_ndctl_list_val(self.plib.run_ndctl_list(856            "-N -r %s" % region)[0], 'size')857        mnt_path = self.params.get('mnt_point', default='/pmemS')858        self.part = partition.Partition(self.disk, mountpoint=mnt_path)859        self.part.mkfs(fstype='xfs', args='-b size=%s -s size=512' %860                       memory.get_page_size())861        if not os.path.exists(mnt_path):862            os.makedirs(mnt_path)863        self.part.mount()...

fixtures.py

Source:fixtures.py

...86  def create_app_repository(namespace, name):87    user = model.user.get_user(namespace)88    model.repository.create_repository(namespace, name, user, repo_kind='application')89    return 'OK'90  def disable_namespace(namespace):91    namespace_obj = model.user.get_namespace_user(namespace)92    namespace_obj.enabled = False93    namespace_obj.save()94    return 'OK'95  def delete_manifests():96    ManifestLegacyImage.delete().execute()97    ManifestBlob.delete().execute()98    Manifest.delete().execute()99    TagManifestToManifest.delete().execute()100    TagManifest.delete().execute()101    return 'OK'102  def set_geo_block_for_namespace(namespace_name, iso_country_code):103    NamespaceGeoRestriction.create(namespace=User.get(username=namespace_name),104                                   description='',...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.