def test_create_workload_fresh_directory(self): workunit1 = self.undertest.get_workunit() assert_that(workunit1.get_filename(), is_in(self.test_files)) self.progress_manager.record_done(workunit1.get_filename()) workunit2 = self.undertest.get_workunit() assert_that(workunit2.get_filename(), is_in(self.test_files)) assert_that(workunit2.get_filename(), is_not(equal_to(workunit1.get_filename()))) self.progress_manager.record_done(workunit2.get_filename()) self.assertRaises(NoAvailableWorkException, self.undertest.get_workunit)
def test_removing_items(self): """ Test that item can be removed from inventory """ item = mock() self.character.inventory.append(item) assert_that(item, is_in(self.character.inventory)) self.character.inventory.remove(item) assert_that(item, is_not(is_in(self.character.inventory)))
def test_deleting_items(self): """ Test that item can be deleted from inventory """ item = mock() self.character.inventory.append(item) assert_that(item, is_in(self.character.inventory)) del self.character.inventory[0] assert_that(item, is_not(is_in(self.character.inventory)))
def step_impl(context): """ :type context behave.runner.Context """ stg_list_cnts = dict() stg_list = list() stg = mysql.select(context.dev_xmart, "select sourcelistingid from xmart.stg_listing;") mysql.close_connection(con=context.dev_xmart) for row in stg: row = str(row) # print("========", id) first_quot = row.find("'") comma = row.find(",") stg_list.append(row[first_quot+1:comma-1]) for aa in context.id_exception: assert_that(aa, is_in(stg_list)) # if aa in stg_list: # print(aa) for bb in stg_list: stg_list_cnts[bb] = stg_list_cnts.get(bb, 0) + 1 # print(stg_list_cnts) for key,val in stg_list_cnts.items(): assert_that(val, is_(1)) print("Assertion complete (2 of 3). Listings that are in the Exceptions table appear only once in Stg table. \n")
def test_title_header(): """The 'title' h1 should read "Log in". """ h1 = splinter_tests.browser.find_by_css("h1.title") assert not h1.is_empty() assert_that("Log in", is_in(h1.first.text))
def AssertResponse( self, response ): assert_that( response.status_code, equal_to( requests.codes.ok ) ) assert_that( HMAC_HEADER, is_in( response.headers ) ) assert_that( self._ContentHmacValid( response ), equal_to( True ) )
def test_target_single(self): """ Targeting a single character should be possible """ spell = self.spell_generator.create_spell(spell_name="healing wind", targets=[self.character]) assert_that(self.character, is_in(spell.targets))
def test_marshal_has_correct_keys(self): key1 = "testKey1" value1 = "testValue1" key2 = "testKey2" value2 = "testValue2" self._order.parse({key1: value1, key2: value2}) marshaldata = self._order.marshal() assert_that(key1, is_in(marshaldata)) assert_that(key2, is_in(marshaldata)) assert_that( dict(self._order), equal_to({"testKey1": "testValue1", "testKey2": "testValue2"}) ) assert_that(value1, marshaldata[key1]) assert_that(value2, marshaldata[key2])
def delete_line(line_id): line = line_read_helper.find_by_id(line_id) if not line: return assert_that(line['protocol'], is_in(['sip', 'sccp']), "Acceptance cannot delete line with protocol '%s'" % line['protocol']) _delete_line_associations(line_id) _delete_line(line)
def test_get_clients(self): # Given self.client['email'] = "*****@*****.**" # When self.tester.post("/clients", data=self.client) get = self.tester.get("/clients") # Then assert_that(get.status_code, equal_to(200)) assert_that(self.client, is_in(loads(get.data)['all']))
def test_caster_is_not_targeted(self): """ Under no circumstances, caster should not be targeted """ params = SpellCastingParameters(caster = self.caster, direction = 7, spell_name = 'proto') targets = targeting_single_target(params) assert_that(self.caster, is_not(is_in(targets)))
def test_targeting_empty_direction(self): """ Targeting to incorrect direction should not add anyone to targets list """ params = SpellCastingParameters(caster = self.caster, direction = 1, spell_name = 'proto') targets = targeting_single_target(params) assert_that(self.target1, is_not(is_in(targets)))
def test_targeting_correct_direction(self): """ When targeting towards character, a spell should hit """ params = SpellCastingParameters(caster = self.caster, direction = 7, spell_name = 'proto') targets = [data.target for data in targeting_single_target(params)] assert_that(self.target1, is_in(targets))
def has_variable(self, variable, expected_value): channels = self._ari.channels.list() candidates = [] for channel in channels: try: value = channel.getChannelVar(variable=variable)['value'] except ARINotFound: continue if value == expected_value: candidates.append(channel.id) return is_in(candidates)
def test_instance_refs_are_garbage_collected(self): """_Package instance refs are garbage collected with old instances""" pkg = _Package() pkg1_repr = "%r" % pkg pkg = _Package() # pkg2_repr = "%r" % pkg gc.collect() reprs = [repr(pkg_inst) for pkg_inst in _Package.instances()] # log.debug("pkg1, pkg2, reprs: %s, %s, %s" # % (pkg1_repr, pkg2_repr, reprs)) assert_that(pkg1_repr, is_not(is_in(reprs)))
def test_get_capability_profile_usage_tags(self): unity = t_unity() tag = "capacity" cp = unity.get_capability_profile(usage_tags=tag) assert_that(cp, instance_of(UnityCapabilityProfileList)) assert_that(len(cp), 1) assert_that(cp[0].existed, equal_to(True)) assert_that(tag, is_in(cp[0].usage_tags)) cp2 = unity.get_capability_profile(usage_tags=[tag]) assert_that(cp2, instance_of(UnityCapabilityProfileList)) assert_that(len(cp2), 1) assert_that(cp2[0].existed, equal_to(True)) assert_that(tag, is_in(cp2[0].usage_tags)) # None tags will not pass to rest url # it's same with get_capability_profile() cp3 = unity.get_capability_profile(usage_tags=None) assert_that(cp3, instance_of(UnityCapabilityProfileList)) assert_that(len(cp3), 2) assert_that(cp3[0].existed, equal_to(True))
def test_all_wines(self): # Given self.wine['name'] = "test_all_wines" # Then post = self.tester.post("/wines", data=self.wine) get_all = self.tester.get("/wines") data = loads(get_all.data)['all'] for wine in data: wine.pop("id") copy = self.wine.copy() copy.pop('type') # When assert_that(get_all.status_code, 200) assert_that(copy, is_in(data))
def test_corners_are_rounded(self): """ Spells with spherical area of effect should not target to square area """ add_character(self.level, (7, 7), self.target3) params = SpellCastingParameters(caster = self.caster, direction = 7, spell_name = 'proto') targets = targeting_spherical_area(params, radius = 2) assert_that(self.target3, is_not(is_in(targets)))
def test_wine_by_type(self): # Given self.wine['name'] = "test_delete_wine" # When post = self.tester.post("/wines", data=self.wine) get_white = self.tester.get("/types/white") data = loads(get_white.data)['all'] for white in data: white.pop('id') copy = self.wine.copy() copy.pop('type') # Then assert_that(get_white.status_code, equal_to(200)) assert_that(copy, is_in(data))
def _create_test_image(self, name): """ Create an test image for tests to use on a datastore """ datastore = self._find_configured_datastore_in_host_config() # ttylinux is the default image that is copied to datastore # when agent starts src_image = Image("ttylinux", datastore) dst_image = Image(name, datastore) # Copy image request = Host.CopyImageRequest(src_image, dst_image) response = self.host_client.copy_image(request) assert_that(response.result, is_in([CopyImageResultCode.OK, CopyImageResultCode.DESTINATION_ALREADY_EXIST])) return dst_image, datastore
def test_country_vocabulary(self): from zope.schema import Choice class IA(Interface): choice = Choice(title=u"Choice", vocabulary=u"Countries") o = object() choice = IA['choice'].bind(o) assert_that(choice.vocabulary, is_(not_none())) assert_that('us', is_in(choice.vocabulary)) term = choice.vocabulary.getTermByToken('us') assert_that(term, has_property('value', "United States")) ext = term.toExternalObject() assert_that(ext, has_entry('flag', u'/++resource++country-flags/us.gif')) assert_that(ext, has_entry('title', 'United States')) schema = JsonSchemafier(IA).make_schema() assert_that(schema, has_entry('choice', has_entry('choices', has_item(ext))))
def getcountry(threeletter="PAK"): print threeletter baseurl = "http://api.worldbank.org/datafiles/%s_Country_MetaData_en_EXCEL.xls" value = {'dsID': 'World Bank', 'region': threeletter, 'source': baseurl % threeletter, 'is_number': True} fh = dl.grab(baseurl % threeletter, [404]) if not fh: return messy = messytables.excel.XLSTableSet(fh) table = xypath.Table.from_messy(list(messy.tables)[0]) indicators = table.filter(is_in(indicator_list)) indname = indicators.shift(x=-1) if not len(indname) == len(indicator_list): print "missing indicators", [x.value for x in indname] code = table.filter(equal_to('Indicator Code')) years = code.fill(xypath.RIGHT) junction = indname.junction(years) for ind_cell, year_cell, value_cell in junction: vdict = dict(value) vdict['indID'] = ind_cell.value vdict['period'] = year_cell.value vdict['value'] = value_cell.value indicator = {'indID': vdict['indID']} nameunits = re.search('(.*)\((.*)\)', vdict['indID']) if nameunits: (indicator['name'], indicator['units']) = nameunits.groups() else: indicator['name'] = vdict['indID'] indicator['units'] = 'uno' Indicator(**indicator).save() v = Value(**vdict) if not v.is_blank(): v.save() print len(session.query(Value).filter(Value.dsID == 'World Bank').all()) session.commit()
def test_simple_status(self): """GET / displays some recent statuses""" instance_path = tempfile.mkdtemp() app.instance_path = instance_path filenames = [] for sha in range(10): filename = os.path.join(app.instance_path, "status_{0}.txt".format(sha)) with open(filename, "w+") as f: f.write("\n".join(["{0}: Signature missing", "{0}: Needs more reviewers"]).format(sha)) filenames.append(filename) tester = app.test_client(self) response = tester.get("/") assert_that(response.status_code, equal_to(200)) for sha in range(10): assert_that("/status/{0}".format(sha), is_in(str(response.data))) shutil.rmtree(instance_path)
def test_install_uninstall(self): lsm = LocalSiteManager(None, None) registration = UtilityRegistration(lsm, None, None, None, None) event = Registered(registration) class IFoo(Interface): pass # If we're not contained, we get proxied! class Foo(Contained): pass install_utility_on_registration(Foo(), 'name', IFoo, event) assert_that(lsm['name'], is_(Foo)) assert_that(lsm.getUtility(IFoo), is_(Foo)) queryNextUtility(lsm['name'], IFoo) uninstall_utility_on_unregistration('name', IFoo, event) assert_that('name', is_not(is_in(lsm))) assert_that(lsm.queryUtility(IFoo), is_(none()))
def step_attacked_by(context, a_, opponent): context.ninja_fight.opponent = opponent # -- VERIFY: Optional part feature. assert_that(a_, is_in(["a", None])) assert_that(opponent, is_in(["Chuck Norris", "samurai"]))
def check_wake_word_file_status(context): """An account that contributed wake word samples has those samples removed.""" deleted_account = context.accounts["foo"] file_repository = WakeWordFileRepository(context.db) files_pending_delete = file_repository.get_pending_delete() assert_that(deleted_account.id, is_in(files_pending_delete))
def assert_filter_by(self, expr): assert_that(expr, is_in(self.filter_by))
def _get_prop(): stack.get() return waiter.expect_that( getattr(stack, property_name).lower(), is_not(is_in(transit_values)))
def check_button_import_key_pair_disabled(self): """Step to check `import Key Pair` disabled if quota exceeded.""" page_keypairs = self._page_keypairs() assert_that( 'disabled', is_in(page_keypairs.button_import_keypair.get_attribute("class")))
def _check_router_rescheduled(): l3_agents = self.get_l3_agents_for_router( router, filter_attrs=config.HA_STATE_ACTIVE_ATTRS, check=False) waiter.expect_that(l3_agents, is_not(empty())) waiter.expect_that(old_l3_agent, is_not(is_in(l3_agents))) return l3_agents
def AssertResponse(self, response): assert_that(response.status_code, equal_to(requests.codes.ok)) assert_that(HMAC_HEADER, is_in(response.headers)) assert_that(self._ContentHmacValid(response), equal_to(True))
def test_contains(self) -> None: assert_that("a", is_in(self.data_backend))
def YcmCoreNotImported_test(self): assert_that('ycm_core', is_not(is_in(sys.modules)))
def is_found(self): bridge_ids = (bridge.id for bridge in self._ari.bridges.list()) return is_in(list(bridge_ids))
def validate_updated_skill_setting_value(context): _get_device_skill_settings(context) assert_that(len(context.device_skill_settings), equal_to(3)) expected_settings_values = dict(textfield='New skill text value') assert_that(expected_settings_values, is_in(context.device_settings_values))
def is_hungup(self): channel_ids = (channel.id for channel in self._ari.channels.list()) return all_of(instance_of(str), not_(is_in(list(channel_ids))))
def is_ringing(self): channels = self._ari.channels.list() channel_ids = (channel.id for channel in channels if channel.json['state'] == 'Ringing') return is_in(list(channel_ids))
def is_ringback(self): # There is currently no way to tell if a channel is ringback or not. It is considered Up. channels = self._ari.channels.list() channel_ids = (channel.id for channel in channels if channel.json['state'] == 'Up') return is_in(list(channel_ids))
def check_request_success(context): assert_that( context.response.status_code, is_in([HTTPStatus.OK, HTTPStatus.NO_CONTENT]) )
def step_impl(context): context.matching = context.search.get_automatic_matching() for i in context.matching: assert_that("wikip", is_in(i))
def _check_router_is_on_agent(): l3_agents = self.get_l3_agents_for_router(router, check=False) return waiter.expect_that(l3_agent, is_in(l3_agents))
def step_impl(context): context.chrome_driver.implicitly_wait(5) context.result = Result(context.chrome_driver) new_url = context.result.get_new_url() assert_that("search?source=", is_in(new_url))
def _check_port_interface_presence(): ports = self._client.get_interfaces_ports(router['id']) matcher = is_in(ports) if not must_present: matcher = is_not(matcher) return waiter.expect_that(port, matcher)
def test_add_widget_simple(): # First, make sure we're at the dashboard page. # (Note: We want the first thing we do in this test function to be a yield, # so that later asserts which aren't contained in yielded functions are not # executed when nose runs this function to acquire the generator.) yield check_we_are_at_dashboard_page # Click 'Add Widget' (also checks that we end up on the 'Create a new # Widget' page) yield click_add_widget # If we click Cancel, do we end up back on the dashboard page? yield click_cancel # Return to Add Widget page yield click_add_widget # Open the username menu, so we can check the links expand_username_menu() # Verify the 'Devices', 'Advanced Options' and 'Manage Account' links yield do_check_link("Devices", splinter_tests.SERVER_URL + "/#/devices") yield do_check_link("Advanced Options", splinter_tests.SERVER_URL + "/#/advanced") yield do_check_link("Manage Account", "https://login.etherios.com/home.do") # 'Cancel' should bring us back to the dashboard yield click_cancel # 'Add Widget' should bring us back there yield click_add_widget # Verify all the other links that should be on this page. for linktext, url in get_general_page_links(): yield do_check_link(linktext, url) # Wait for Angular to catch up to us (specifically, to allow Angular to # fetch the user's devices and populate the selection box) do_sleep() # Test how selecting a gateway changes the error state on the page # TODO Should this go in something like test_add_widget_page? gateway_selection_row = browser.find_by_xpath( # Find the 'select' with name 'device', get its grandparent '//select[@name = "device"]/../..') assert not gateway_selection_row.is_empty() assert gateway_selection_row.first.has_class('has-error') # There should also be some error text near the top of the page # Find the list item with a bold "Gateway:" string inside it err_item_xpath = ("//div[contains(@class, 'alert alert-danger')]/ul/li" "/strong[.='Gateway:']/..") gateway_error = browser.find_by_xpath(err_item_xpath) assert not gateway_error.is_empty() # Check that this item is visible on the page assert gateway_error.first.visible # The error should be 'You need to select a gateway' assert_that("You need to select a gateway", is_in(gateway_error.text)) # If we select a gateway, the has-error class should go away # test_user has only one device, so select value 0 browser.select("device", "0") assert not gateway_selection_row.first.has_class('has-error') # The error should also disappear # The 'Gateway:' error item is only hidden when the value becomes valid, # and not destroyed, so we can reuse the gateway_error variable from above assert not gateway_error.first.visible
def _assert_no_docker_image_running(self, name): assert_that(name, is_not(is_in(sh.docker('ps'))))
def impl(context, character_name, place_name): character = get_character(context, character_name) place = get_location(context, place_name) assert_that(character, is_not(is_in(place['\ufdd0:characters'])))
def test_demonizedoptionsilence(self): sys.stdout = MemoryWriter() sys.stderr = MemoryWriter() sys.stdin = MemoryReader() fh = open(ACONFIG, 'w') fh.write('info = green, on_blue\n') fh.write('debug = yellow\n') fh.close() class OptionsMock2(object): def __init__(self): pass def __getattr__(self, method): if method == 'silence': return True if method == 'configfile': return ACONFIG return False class ActionMock(object): def __init__(self): pass def notify(self, message, log): pass def connectSMTP(self): pass def setup_mail(properties): return ActionMock() def wait_for(secs): if self.raise_count == 0: write_log() return raise KeyboardInterrupt def chdir(directory): return True def umask(integer): return True def setsid(): return True def dup2(one, two): return True def fork(): return -1 onelogtrace = 'this is an info booo log trace' anotherlogtrace = 'this is a debug log trace' def write_log(): fh = open(self.log_name, 'a') fh.write(onelogtrace + '\n') fh.write(anotherlogtrace + '\n') fh.close() self.raise_count += 1 log4tailer.setup_mail = setup_mail options_mock = OptionsMock2() args = [self.log_name] default_config = DefaultConfig() log4tailer.setup_config(options_mock, default_config) os.fork = fork os.chdir = chdir os.setsid = setsid os.dup2 = dup2 os.umask = umask log4tailer.monitor(options_mock, args, default_config, wait_for) expectedlogtrace = ("\x1b[32m\x1b[44mthis is an info booo log " "trace\x1b[0m") assert_that(expectedlogtrace, is_in(sys.stdout.captured))
def _check_router_rescheduled(): l3_agents = self._client.get_l3_agents_for_router(router['id']) return waiter.expect_that(old_l3_agent, is_not(is_in(l3_agents)))
def YouCompleteMe_YcmCoreNotImported_test( ycm ): assert_that( 'ycm_core', is_not( is_in( sys.modules ) ) )
def _check_network_rescheduled(): dhcp_agents = self._client.get_dhcp_agents_for_network( network['id']) dhcp_agents_ids = [agent['id'] for agent in dhcp_agents] return waiter.expect_that(old_dhcp_agent['id'], is_not(is_in(dhcp_agents_ids)))
def test_empty_input_does_not_raise_500(self): """ Ensure empty/unsaved data does not raise 500s in serializer. """ response = self.create_empty_via_api() assert_that(response.status_code, is_in([201, 400]))
'source': baseurl.format(threeletter.lower()), 'is_number': True} while True: fh = dl.grab(baseurl.format(threeletter), [404]) if not fh: return try: messy = messytables.excel.XLSTableSet(fh) break # success! except messytables.error.ReadError, e: print e return table = xypath.Table.from_messy(list(messy.tables)[0]) indicators = table.filter(is_in(indicator_list)) indname = indicators.shift(x=-1) if not len(indname) == len(indicator_list): print "missing indicators", [x.value for x in indname] code = table.filter(equal_to('Indicator Code')) years = code.fill(xypath.RIGHT) junction = indname.junction(years) for ind_cell, year_cell, value_cell in junction: vdict = dict(value) vdict['indID'] = ind_cell.value vdict['period'] = year_cell.value vdict['value'] = value_cell.value indicator = {'indID': vdict['indID']}
def YcmCoreNotImported_test( self ): assert_that( 'ycm_core', is_not( is_in( sys.modules ) ) )
def check_for_added_files(context): def check_command_entity_association(cfile_id): c_result = context.connection.post(Statement("MATCH (e:FILE_ENTITY) <-[APPLIED_TO]- (c:COMMAND) " "WHERE id(e) = {} RETURN c".format(context.mapping[cfile_id]))) assert_that(len(c_result[0]['data']), is_(1), "Exactly one file data associated with " + file) entities = context.connection.find("FILE_ENTITY") assert_that(len(entities), is_(6), "We found 6 entities") # Make sure that the file entities are associated with one command object each for file in ["A", "B", "C", "D", "E", "F"]: check_command_entity_association(file) commands = context.connection.find("COMMAND") assert_that(len(commands), is_(6), "We found 6 commands") command_mapping = {} # Set up a mapping between filenames and commands operating on those files for command in commands: print(command[1]['data']) c_data = json.loads(command[1]['data']) if 'filename' in c_data: command_mapping[c_data['filename']] = command[1] command_mapping[c_data['filename']]['data'] = c_data # Verify that the data and type of each command is as expected assert_that(command_mapping["File A"]['data']['content'], is_("VGhpcyBpcyB0aGUgZmlsZSdzIGNvbnRlbnQ=")) assert_that('content', not is_in(command_mapping["Directory B"]['data'])) assert_that(command_mapping["File C"]['data']['content'], is_("U29tZSBvdGhlciBjb250ZW50")) assert_that('content', not is_in(command_mapping["File C"]['data'])) assert_that(command_mapping["File D"]['data']['content'], is_("U3RpbGwgbW9yZSBjb250ZW50")) assert_that(command_mapping["File F"]['data']['content'], is_("SW50ZXJpb3Igc3R1ZmY=")) assert_that(command_mapping["File A"]['data']['type'], is_("file")) assert_that(command_mapping["Directory B"]['data']['type'], is_("directory")) assert_that(command_mapping["File C"]['data']['type'], is_("file")) assert_that(command_mapping["File D"]['data']['type'], is_("file")) assert_that(command_mapping["Directory E"]['data']['type'], is_("directory")) assert_that(command_mapping["File F"]['data']['type'], is_("file")) assert_that(command_mapping["File A"]['type'], is_("create")) assert_that(command_mapping["Directory B"]['type'], is_("create")) assert_that(command_mapping["File C"]['type'], is_("create")) assert_that(command_mapping["File D"]['type'], is_("create")) assert_that(command_mapping["Directory E"]['type'], is_("create")) assert_that(command_mapping["File F"]['type'], is_("create")) # Ensure that the commands are associated with the previous revision id commands_associated = context.connection.post(Statement("MATCH (c:COMMAND) -[:OCCURRED]-> " "(r:REVISION) WHERE id(r) = {} RETURN c" .format(context.first_rev))) assert_that(len(commands_associated[0]['data']), is_(6), "We found 6 commands") # Make sure that the commit updated the current revision and left nothing behind. result = context.connection.post(Statement("MATCH (:BRANCH {name:'head'}) <-[:AT]- (r:REVISION) return r")) assert_that(len(result[0]['data']), is_(1), "There was only one current revision") result = context.connection.post(Statement("MATCH (:BRANCH {name: 'head'}) <-[:AT]- (r:REVISION) -[:APPLIED_TO]-> (n) return n")) assert_that(len(result[0]['data']), is_(0), "The new revision has no commands associated with it")
def subscribed(): try: assert_that(uuid, not_(is_in(sentinel.consumers()))) except requests.exceptions.ConnectionError: raise AssertionError()
def assert_status(self, *statuses): assert_that(statuses, only_contains(instance_of(int))) assert_that(self.response.status_code, is_in(statuses), self.response.text)
def _check_network_is_on_agent(): dhcp_agents = self._client.get_dhcp_agents_for_network( network['id']) return waiter.expect_that(dhcp_agent, is_in(dhcp_agents))