from mamba import describe, it, context from unittest.mock import MagicMock from test_utils.anki import mock_anki_modules mock_anki_modules() from crowd_anki.export.anki_exporter_wrapper import AnkiJsonExporterWrapper DUMMY_EXPORT_DIRECTORY = "/tmp" TEST_DECK_ID = 1 with describe(AnkiJsonExporterWrapper) as self: with context("user is trying to export dynamic deck"): with it("should warn and exit without initiating export"): exporter_mock = MagicMock() notifier_mock = MagicMock() collection_mock = MagicMock() collection_mock.decks.get.return_value = {'dyn': True} subject = AnkiJsonExporterWrapper(collection_mock, TEST_DECK_ID, exporter_mock, notifier_mock) subject.exportInto(DUMMY_EXPORT_DIRECTORY) notifier_mock.warning.assert_called_once() exporter_mock.export_to_directory.assert_not_called()
CONFIG = Config(os.path.join(os.path.dirname(__file__), os.environ.get('MAMBA_CONFIG', 'config.yaml'))) with description('Ports,', 'ports') as self: with description('REST API,'): with before.all: service = Service(CONFIG.service()) self.process = service.start() self.api = client.api.PortsApi(service.client()) with description('list,'): with description('unfiltered,'): with it('returns valid ports'): ports = self.api.list_ports() expect(ports).not_to(be_empty) for port in ports: expect(port).to(be_valid_port) with description('filtered,'): with description('known existing kind,'): with it('returns valid ports of that kind'): ports = self.api.list_ports(kind='dpdk') expect(ports).not_to(be_empty) for port in ports: expect(port).to(be_valid_port) expect(port.kind).to(equal('dpdk')) with description('known non-existent kind,'):
from thrift import Thrift from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from mamba import description, context, it from expects import expect, equal import json test_doc_path = './data/test_doc.json' try: with description('ThriftKV') as self: doc_id = '' with it('the create method is called and returns a mongo object id'): transport = TSocket.TSocket('0.0.0.0', 9090) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = ThriftKVService.Client(protocol) transport.open() # Get thrift client and open transport protocol with open(test_doc_path) as f: global doc_id doc = f.read() doc_id = json.loads(client.create(doc)) expect('$oid' in doc_id.keys()) transport.close()
from mamba import description, context, it, before, after from expects import equal, expect, be_a, be, have_len, be_true, contain from places import Square from board import Board from pieces import * from move import Move from game import Game with description('board') as self: with it('allows en passant as an option'): b = Board() m1 = b._make_move('a1a4') b.move(m1) m2 = b._make_move('b6b4') b.move(m2) expect(b.grid['a'][4].piece.available_moves(b)).to( contain(b.grid['b'][5])) with it('allows en passant only if the pawn move was last turn'): b = Board() m1 = b._make_move('a1a4') b.move(m1) m2 = b._make_move('b6b4') b.move(m2)
from mamba import description, it from expects import expect, have_length, be_above import os import infrastructure with description(infrastructure.AnchoreClient) as self: with it('retrieves images with stop policy results'): user = os.environ['ANCHORE_CLI_USER'] password = os.environ['ANCHORE_CLI_PASS'] url = os.environ['ANCHORE_CLI_URL'] client = infrastructure.AnchoreClient(user, password, url, True) result = client.get_images_with_policy_result('stop') expect(result).to(have_length(be_above(1)))
from mamba import description, it with description('Fixture#without_inner_contexts'): with it('first example'): pass with it('second example'): pass with it('third example'): pass
from mamba import shared_context, it with shared_context('Shared Context'): with it('example'): pass
from mamba import description, context, it from expects import expect, contain with description('checking if string contains a character'): with context('given a character and a string'): with context('when the string contains the character'): with it('returns true'): character = 'C' string = 'PyConES2018' expect(string).to(contain(character)) with context('when the string does NOT contain the character'): with it('return false'): character = 'x' string = 'PyConES2018' expect(string).not_to(contain(character))
from mamba import description, context, it try: from unittest.mock import patch except ImportError: from mock import patch from expects import expect, be class ExampleClass(object): def hello(self): return 'Hello' with description('Testing with unittest.mock'): with context('when class method is mocked'): with it('returns mocked value'): with patch.object(ExampleClass, 'hello', return_value='World!') as mock_method: expect(mock_method()).to(be('World!'))
from mamba import describe, it, context from unittest.mock import MagicMock from crowd_anki.export.anki_exporter_wrapper import AnkiJsonExporterWrapper DUMMY_EXPORT_DIRECTORY = "/tmp" TEST_DECK_ID = 1 with describe(AnkiJsonExporterWrapper) as self: with context("user is trying to export dynamic deck"): with it("should warn and exit without initiating export"): exporter_mock = MagicMock() notifier_mock = MagicMock() collection_mock = MagicMock() collection_mock.decks.get.return_value = {'dyn': True} subject = AnkiJsonExporterWrapper(collection_mock, TEST_DECK_ID, exporter_mock, notifier_mock) subject.exportInto(DUMMY_EXPORT_DIRECTORY) notifier_mock.warning.assert_called_once() exporter_mock.export_to_directory.assert_not_called()
PENDING_DECORATOR_AS_ROOT_PATH = spec_abspath('with_pending_decorator_as_root.py') WITH_RELATIVE_IMPORT_PATH = spec_abspath('with_relative_import.py') WITH_TAGS_PATH = spec_abspath('with_tags.py') WITH_FOCUS_PATH = spec_abspath('with_focus.py') SHARED_CONTEXT_PATH = spec_abspath('with_shared_context.py') INCLUDED_CONTEXT_PATH = spec_abspath('with_included_context.py') def _load_module(path): example_collector = ExampleCollector([path]) return list(example_collector.modules())[0] with description(ExampleCollector): with context('when loading from file'): with it('loads module from absolute path'): module = _load_module(IRRELEVANT_PATH) expect(inspect.ismodule(module)).to(be_true) with it('loads module from relative path'): module = _load_module(spec_relpath('without_inner_contexts.py')) expect(inspect.ismodule(module)).to(be_true) #FIXME: Mixed responsabilities in test [collect, load]?? with context('when loading'): with it('orders examples by line number'): module = _load_module(spec_abspath('without_inner_contexts.py')) examples = loader.Loader().load_examples_from(module)
from mamba import description, it from unittest.mock import MagicMock from test_utils.anki import mock_anki_modules mock_anki_modules() from crowd_anki.anki.hook_vendor import HookVendor from crowd_anki.utils.config import AUTOMATED_SNAPSHOT with description(HookVendor): with it('should only setup snapshot hooks if plugin config says so'): hook_manager = MagicMock() vendor = HookVendor(MagicMock(), hook_manager) vendor.config = {AUTOMATED_SNAPSHOT: False} vendor.setup_snapshot_hooks() hook_manager.hook.assert_not_called()
def staged_files(repository): staged = porcelain.status(repository.dulwich_repo).staged return staged['modify'] + staged['add'] def mock_git_interface(add=tuple()): git = MagicMock() git.status.return_value = GitStatus(dict(add=add, modify=[], delete=[]), [], []) return git with description(DulwichAnkiRepo) as self: with context('init'): with it("should use existing repo if it's present"): with TemporaryDirectory() as dir_name: repo_path = Path(dir_name) dulwich_repo = porcelain.init(repo_path) assert_repo_exists_at_given_path_after_init(repo_path) with it('should create a new repo if it does not exist'): with TemporaryDirectory() as dir_name: repo_path = Path(dir_name) assert_repo_exists_at_given_path_after_init(repo_path) with context('add_all'): with it("should add new files"): with TemporaryDirectory() as dir_name:
self.chassis = '172.18.0.2' self.slot = 1 self.port = 1 #print(os.environ) if os.environ.has_key('CSP1'): (self.chassis, self.slot, self.port) = extract_chassis(os.environ['CSP1']) # conn and msg_set is a must for calling send_message self.conn = connect_chassis(self.chassis) self.msg_set_name = 'admin_1' self.reservedports = False with after.all: # Don't use multiple before.all/after.all(or .each) in different contexts, see https://github.com/nestorsalceda/mamba/issues/130 for details pass # The last test case has released the port with it('gets port group type'): msg_name = 'admin_1.GetPortGroupType' msg_content = { "portGroup": [{ "slot": -1, "portGroup": -1, "port": -1 }] } resp_dict = send_msg(self, self.conn, msg_name, msg_content) portTypeList = resp_dict['pgTypeList'] expect(portTypeList[0]['pgType']).to(equal('VM-1G-V1-1P')) with it('gets the port status'): msg_name = 'admin_1.GetPortGroupPortStatus' msg_content = {
from mamba import shared_context, included_context, describe, it SHARED_CONTEXT = 'Shared Context' with shared_context(SHARED_CONTEXT): with it('shared example'): pass with describe('Real tests'): with included_context(SHARED_CONTEXT): with it('added example'): pass
from mamba import description, context, it from expects import expect, equal def fibonacci(index): pass with description('fibonacci specs'): with context('for index 0'): with it('has value 0'): index = 0 value = fibonacci(index) expect(value).to(equal(0))
from mamba import description, it, before, context from expects import expect, be_none, raise_error import os from playbooks import infrastructure with description(infrastructure.PhantomClient) as self: with before.each: self.phantom_client = infrastructure.PhantomClient( os.environ['PHANTOM_USER'], os.environ['PHANTOM_PASSWORD'], os.environ['PHANTOM_BASE_URL'], verify_ssl=False) with it('creates a container in Phantom Server'): container = { 'name': 'My Container', 'description': 'Useful description of this container.', 'label': 'events', 'run_automation': False, 'severity': 'high', 'status': 'new', 'start_time': '2015-03-21T19:28:13.759Z', } container = self.phantom_client.create_container(container) expect(container['id']).not_to(be_none) with context('when an error happens'):
"sentiment": "Positive", "tickers": ["AAPL"], "summary": "sample summary", "timestamp": "1579141155" }], "timestamp": 1579125281, "size": 4 }] with description('Graphelier News:') as self: with it('should make sure the root url is exposed'): root_response = TESTING_CLIENT.get('/') response_data = root_response.get_json() expect(root_response.status_code).should.equal(200) response_data['message'].should.equal('Graphelier News') with it('should make sure the news clusters url is exposed'): with patch('server.views.fetch_n_clusters_from_time') as mock_fetch: mock_fetch.return_value = [] nc_response = TESTING_CLIENT.get('/news_clusters/123') with it('should return a 400 on a non-int timestamp'): with patch('server.views.fetch_n_clusters_from_time') as mock_fetch: mock_fetch.return_value = [] nc_response = TESTING_CLIENT.get('/news_clusters/12asdf3') response_data = nc_response.get_json()
from mamba import description, context, it from expects import expect, equal import tennis with description('Tennis') as self: with it('starts with 0 - 0 score'): rafa_nadal = "Rafa Nadal" roger_federer = "Roger Federer" game = tennis.Game(rafa_nadal, roger_federer) expect(game.score()).to(equal((0, 0)))
from expects import expect, be from mamba import description, it from unittest.mock import MagicMock from crowd_anki.representation import deck_initializer DYNAMIC_DECK = {'dyn': True} TEST_DECK = "test deck" with description("Initializer from deck") as self: with it("should return None when trying to export dynamic deck"): collection = MagicMock() collection.decks.byName.return_value = DYNAMIC_DECK expect(deck_initializer.from_collection(collection, TEST_DECK)).to(be(None))
from mamba import description, it from expects import expect, be_none from amadeus import version with description('Amadeus') as self: with it('should have a version'): expect(version).not_to(be_none)
from mamba import description, context, it with description('Refactoring Goodies') as self: with it('allows calling a defined method inside the example group'): assert self.hello('python') != self.hello('pandas') def hello(self, world): return 'hello, %s'.format(world)
WITH_RELATIVE_IMPORT_PATH = spec_abspath('with_relative_import.py') WITH_TAGS_PATH = spec_abspath('with_tags.py') WITH_FOCUS_PATH = spec_abspath('with_focus.py') SHARED_CONTEXT_PATH = spec_abspath('with_shared_context.py') INCLUDED_CONTEXT_PATH = spec_abspath('with_included_context.py') HELPER_METHODS_PATH = spec_abspath('with_helper_methods.py') def _load_module(path): example_collector = ExampleCollector([path]) return list(example_collector.modules())[0] with description(ExampleCollector): with context('when loading from file'): with it('loads module from absolute path'): module = _load_module(IRRELEVANT_PATH) expect(inspect.ismodule(module)).to(be_true) with it('loads module from relative path'): module = _load_module(spec_relpath('without_inner_contexts.py')) expect(inspect.ismodule(module)).to(be_true) #FIXME: Mixed responsabilities in test [collect, load]?? with context('when loading'): with it('orders examples by line number'): module = _load_module(spec_abspath('without_inner_contexts.py')) examples = loader.Loader().load_examples_from(module)
from mamba import description, it, _it from pathlib import Path from unittest.mock import MagicMock from crowd_anki.anki.adapters.anki_deck import AnkiDeck from crowd_anki.history.anki_deck_archiver import AnkiDeckArchiver with description(AnkiDeckArchiver) as self: with it("inits repo, archives the deck there and commits"): base_path = Path('dummy_dir') deck_path = base_path.joinpath('deck_name') deck_exporter_mock = MagicMock() deck_exporter_mock.export_to_directory.return_value = deck_path repo_mock = MagicMock() deck = AnkiDeck({}) archival_reason = "whee" AnkiDeckArchiver(deck, base_path, deck_exporter_mock, lambda _: repo_mock).archive(reason=archival_reason) deck_exporter_mock.export_to_directory.assert_called_once_with(deck, base_path) repo_mock.stage_all.assert_called_once() repo_mock.commit.assert_called_once_with(archival_reason) with _it("should delete all existing content of the repo before adding new one"): ''' Not sure if this is a good idea, this will help with cleaning out the media files not used anymore but may adversely affect the user if they are to add custom things to the repo. I can consider making this configurable per repo. '''
from mamba import description, context, it from expects import * from services.list_attendees import ListAttendees with description('ListAttendees') as self: with it('returns a list'): expected = [{'name': 'Foo'}, {'name': 'Bar'}] expect(expected == ListAttendees().list.run().value.result).to(be_true)
from mamba import description, context, it from expects import expect, equal import file_extractor import regex_project_type with description('File Extractor'): with context('for a python project'): with context('given a list of files'): with it('gets the python files'): python_regex = regex_project_type.RegexProjectGenerator( ['python']).regex()[0] test_file_list = ['foo.py', 'foo.txt'] _file_extractor = file_extractor.FileExtractorFromRegex( python_regex) result = _file_extractor.process(test_file_list) expect(result).to(equal(['foo.py']))
# https://github.com/nestorsalceda/mamba from mamba import description, context, it from expects import expect, equal from create_stan_lang import * with description("parse_args") as self: with it("parses empty argument correctly"): expect(parse_args("")).to(equal([])) # with it("parses ~ argument correctly regardless of spaces"): expect(parse_args("~")).to(equal(None)) expect(parse_args("~ ")).to(equal(None)) expect(parse_args("~ ")).to(equal(None)) expect(parse_args(" ~")).to(equal(None)) expect(parse_args(" ~")).to(equal(None)) expect(parse_args(" ~ ")).to(equal(None)) # with it("parses single argument into a single element list"): expect(parse_args("T x")).to(equal([{'type': 'T', 'name': 'x'}])) expect(parse_args("reals theta")).to(equal([{'type': 'reals', 'name': 'theta'}])) # with it("parses multiple arguments into a multi-element list"): expect(parse_args("T x, T y") ).to(equal([{'type': 'T', 'name': 'x'}, {'type': 'T', 'name': 'y'}])) expect(parse_args("matrix x, matrix y") ).to(equal([{'type': 'matrix', 'name': 'x'}, {'type': 'matrix', 'name': 'y'}]))
from common import Config, Service from common.matcher import be_valid_module, raise_api_exception CONFIG = Config( os.path.join(os.path.dirname(__file__), os.environ.get('MAMBA_CONFIG', 'config.yaml'))) with description('Modules, ', 'modules') as self: with before.all: service = Service(CONFIG.service()) self.process = service.start() self.api = client.api.ModulesApi(service.client()) with description('list, '): with description('all, '): with it('returns list of modules'): modules = self.api.list_modules() expect(modules).not_to(be_empty) for module in modules: expect(module).to(be_valid_module) with description('unsupported method, '): with it('returns 405'): expect(lambda: self.api.api_client.call_api( '/modules', 'PUT')).to( raise_api_exception(405, headers={'Allow': "GET"})) with description('get, '): with description('known module, '): with description('packetio'): with it('succeeds'):
from mamba import description, it with description('Fixture#with_tags', 'integration'): with it('first example', 'unit'): pass
review_dict = { 'id': REVIEW_UUID, 'text': 'scathing review - pigs cant talk' } with app.app_context(): db.drop_all() db.create_all() db.session.add(author_model) db.session.add(book_model) db.session.add(review_model) db.session.commit() with description('model_to_dict') as self: with it('converts a flat model into a dict'): with app.app_context(): retrieved_book = Book.query.filter_by(book_id=BOOK_UUID).first() result = model_to_dict( sqlalchemy_model=retrieved_book, ) expect(result).to(have_keys(**book_dict)) with it('converts a singly-nested relationship'): with app.app_context(): retrieved_book = Book.query.\ filter_by(book_id=BOOK_UUID).\ options(joinedload('author')).\ first() result = model_to_dict( sqlalchemy_model=retrieved_book,
def snmp_integer(value): return types.PySnmpValue(types.PySnmpTypes().integer(value)) def snmp_octect_string(value): return types.PySnmpValue(types.PySnmpTypes().octect_string(value)) with description('SNMP Client') as self: with before.each: self.snmp_client = clients.PySnmpClient() with context('FEATURE: snmpget'): with context('happy path'): with it('returns the values'): oid1 = '1.3.6.1.4.1.4998.1.1.10.1.4.2.1.29.1.10' oid2 = '1.3.6.1.4.1.4998.1.1.10.1.4.2.1.29.1.11' result = self.snmp_client.get(SNMP_HOST, READ_ONLY_COMMUNITY, [oid1, oid2], port=SNMP_PORT) expect(result).to( equal([(oid1, snmp_integer(999)), (oid2, snmp_integer(31))])) with context('having an invalid community'): with it('raises an exception after a timeout'): oid = '1.1'
from mamba import description, it, context from expects import expect, equal RETURN_VALUE = '42' with description('Refactoring goodies') as self: def a_method(self, return_value=RETURN_VALUE): return return_value with it('uses methods defined inside its context'): expect(self.a_method()).to(equal(RETURN_VALUE)) with context('when using nested contexts'): with it('uses methods defined inside its parent'): expect(self.a_method()).to(equal(RETURN_VALUE)) with describe('Execution context of methods'): with context('When the value is defined in a before all hook of the same context'): def method_with_context(self): return self.context_value with before.all: self.context_value = RETURN_VALUE with it('returns the value defined in the before all hook'): expect(self.method_with_context()).to(equal(RETURN_VALUE))
from mamba import description, it from expects import expect, equal, be_an, be_none from problems.string.roman import roman_to_arabic, arabic_to_roman, is_roman with description('roman_to_arabic') as self: with it('should return the Arabic representation of a Roman numeral' ) as self: expect(roman_to_arabic('MDCCCLXVI')).to(equal(1866)) expect(roman_to_arabic('XIV')).to(equal(14)) expect(roman_to_arabic('LXXXIX')).to(equal(89)) expect(roman_to_arabic('XCI')).to(equal(91)) expect(roman_to_arabic('DCCCXC')).to(equal(890)) expect(roman_to_arabic('MCMLXXXIX')).to(equal(1989)) with description('arabic_to_roman') as self: with it('should return the Roman representation of an Arabic numeral' ) as self: expect(arabic_to_roman(1666)).to(equal('MDCLXVI')) expect(arabic_to_roman(91)).to(equal('XCI')) with description('is_roman') as self: with it('should not accept more than three consecutive numerals') as self: expect(is_roman('XXXX')).to(be_none) with it('should reject any sequential repetition of V, L, or D') as self: expect(is_roman('LL')).to(be_none) expect(is_roman('DDC')).to(be_none) expect(is_roman('XVV')).to(be_none) with it('should allow valid exceptions of order') as self: expect(is_roman('IV')).to(be_an(object)) expect(is_roman('IX')).to(be_an(object)) expect(is_roman('XC')).to(be_an(object)) expect(is_roman('XL')).to(be_an(object)) expect(is_roman('CD')).to(be_an(object))
from mamba import description, context, it from expects import expect, equal import json from blsqpy.descriptor import Descriptor def json_fixture_content(filename): print("reading", filename) with open(filename+".json", encoding='utf-8') as f: return json.loads(f.read()) with description('Parsing json config') as self: with it('loads them as namedTupples'): config = Descriptor.load("./specs/fixtures/config/demo") expect(config.demo.test.hello).to(equal("world")) with it('loads them as namedTupples and normalize states'): config = Descriptor.load("./specs/fixtures/config/parametrized-raw") jsonDescriptor = Descriptor.to_json(config) print(jsonDescriptor) expect(json.loads(jsonDescriptor)).to( equal( json_fixture_content( "./specs/fixtures/config/parametrized-final")) )
import pandas as pd from mamba import description, context, it, before from expects import expect, equal from blsqpy.levels import Levels with description('levels') as self: with it('to_level_uid'): path = "/vJRQh3jzmwU/lZTyT0gbMS6/C2qfrNWcbjx/nxIbiSpPubg" expect( [ Levels.to_level_uid(path, 1), Levels.to_level_uid(path, 2), Levels.to_level_uid(path, 3), Levels.to_level_uid(path, 4), Levels.to_level_uid(path, 5), Levels.to_level_uid(path, 6), ] ).to(equal([ 'vJRQh3jzmwU', 'lZTyT0gbMS6', 'C2qfrNWcbjx', 'nxIbiSpPubg', None, None] )) with it('max_level'): def expect_level(paths, expected_level): df = pd.DataFrame(data=paths,
import requests import time import configuration from mamba import description, context, it from expects import expect, be_true, have_length, equal, be_a, have_property, be_none headers = {'content-type': 'application/json', 'accept': 'application/json'} with description('Zipkin tracing functionality'): with before.all: #Read Config file configuration.setenv(self) with context('Deploy Zipkin and make sure port forwarded to localhost'): with it('Bookinfo Zipkin tracing feature'): for _ in range(10): r = requests.get(self.url) r.status_code expect(r.status_code).to(equal(200)) r1 = requests.get(self.zipkin) r1.status_code expect(r1.status_code).to(equal(200)) if 'productpage' in r1.text: expect(0).to(equal(0)) else: expect(0).not_to(equal(0)) configuration.generate_request(self)
with description("Policies v1") as self: with before.all: self.clientV1 = SdSecureClientV1(sdc_url=os.getenv( "SDC_SECURE_URL", "https://secure.sysdig.com"), token=os.getenv("SDC_SECURE_TOKEN")) with after.each: self.cleanup_policies() def cleanup_policies(self): _, res = self.clientV1.list_policies() for policy in res['policies']: if str(policy["name"]).startswith("Test - "): ok, res = self.clientV1.delete_policy_id(policy["id"]) expect((ok, res)).to(be_successful_api_call) with it("is able to list all existing policies"): ok, res = self.clientV1.list_policies() expect((ok, res)).to(be_successful_api_call) with it("is able to list all policies priorities"): ok, res = self.clientV1.get_policy_priorities() expect((ok, res)).to(be_successful_api_call) with it("is able to change the evaluation order of policies"): ok, res = self.clientV1.get_policy_priorities() random.shuffle(res['priorities']['policyIds']) ok, res = self.clientV1.set_policy_priorities(json.dumps(res)) expect((ok, res)).to(be_successful_api_call) with it("is able to add a policy from JSON"): call = self.clientV1.add_policy(policy_json())
from mamba import description, context, it from expects import expect, equal with description('Addition') as self: with it('adds two numbers'): expect(1 + 1).to(equal(2))
from unittest.mock import MagicMock from expects import expect, contain from mamba import describe, it, context from test_utils.anki import mock_anki_modules mock_anki_modules() from aqt import mw from crowd_anki.config.config_settings import ConfigSettings, NoteSortingMethods with describe(ConfigSettings) as self: with context("someone interacts with any config setting"): with it("do not sort / sort by none"): config = ConfigSettings(mw.addonManager, { "automated_snapshot": True }) assert config.automated_snapshot with it("get all the NoteSortingMethod values"): valid_sorting_methods = list(NoteSortingMethods.values()) assert len(valid_sorting_methods) > 0 assert isinstance(valid_sorting_methods, list) with it("tries to find the invalid config entries"): config = ConfigSettings(mw.addonManager) valid_sorting_methods = list(NoteSortingMethods.values())
from multiprocessing import Queue from queue import PriorityQueue import array import heapq class Car: def __init__(self, color, mileage, automatic): self.color = color self.mileage = mileage self.automatic = automatic with description('Chapter05') as self: with context('dicts'): with it('fast lookup'): phonebook: Dict[str, int] = { 'bob': 7387, 'alice': 3719, 'jack': 7052, } assert phonebook['alice'] == 3719 squares = {x: x * x for x in range(6)} assert len(squares.keys()) == 6 with context('ordered dict'): with it('keeps keys in order'): d = OrderedDict(one=1, two=2, three=3) assert d['two'] == 2 d['four'] = 4
from mamba import _description, it, context with _description('Fixture#with_pending_decorator_as_root'): with it('pending spec'): pass with context('when pending context'): with it('pending spec inside context'): pass