def testCanTestBoolDirectlyWithoutReason(self): assert_that(True) with self.assertRaises(AssertionError) as e: assert_that(False) self.assertEqual('Assertion failed', str(e.exception))
def test_element(): ElementTest = xmlfied('element_test', ab=Element()) a = ElementTest(ab='foo') assert_that(get_xml_string(a.toxml()), string_contains_in_order('<element_test>', '<ab>foo</ab>', '</element_test>'))
def test_stop_game_with_nogame_status(self): when(self.server_proxy_spy.move).then_return(("NoGame", 0)) self.robot.start(max_moves=10) assert_that(self.robot.status, equal_to("NoGame")) assert_that(self.robot.total_moves, equal_to(1))
def test_win_in_a_move(self): when(self.server_proxy_spy.move).then_return(("YouWin", 10)) self.robot.start(max_moves=2) assert_that(self.robot.status, equal_to("YouWin")) assert_that(self.robot.total_moves, equal_to(1))
def test_game_over_in_a_move(self): when(self.server_proxy_spy.move).then_return(("GameOver", 0)) self.robot.start(max_moves=10) assert_that(self.robot.status, equal_to("GameOver")) assert_that(self.robot.total_moves, equal_to(1))
def test_dont_move_to_bad_cell_score(self): self.next_cell_calculator.cell_scores = {2: 8, 3: 10} self.next_cell_calculator.seek = 1 self.next_cell_calculator.min_cell_score_to_move = 12 self.next_cell_calculator.last_cell = Cell(1, 5) assert_that(self.next_cell_calculator.next(), equal_to(4))
def test_move_to_high_cell_score(self): self.next_cell_calculator.cell_scores = {1: 10, 2: 50, 3: 5} self.next_cell_calculator.seek = 3 self.next_cell_calculator.last_cell = Cell(3, 5) assert_that(self.next_cell_calculator.next(), equal_to(2))
def test_unitValue(self): for unit in self.multiResult.units: result = self.multiResult.unitValue(unit) if unit is unit1: assert_that(result, equal_to(self.unit1Value * self.numTimes)) elif unit is unit2: assert_that(result, equal_to(self.unit2Value * self.numTimes))
def testCanTestBoolDirectly(self): assert_that(True, 'should accept True') try: assert_that(False, 'FAILURE REASON') except AssertionError, e: self.assertEqual('FAILURE REASON', str(e)) return
def testCanTestBoolDirectlyWithoutReason(self): assert_that(True) try: assert_that(False) except AssertionError, e: self.assertEqual('Assertion failed', str(e)) return
def test_no_more_than_one_move_at_a_minimum(self): self.server_proxy.move("robocop", 10) time1 = datetime.now() self.server_proxy.move("robocop", 12) time2 = datetime.now() assert_that( (time2 - time1).microseconds, greater_than_or_equal_to(200))
def testWarnsForMatcherAsArg1(self): assert_that(True) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") assert_that(equal_to(1)) self.assertEqual(len(w), 1) self.assertTrue("arg1 should be boolean" in str(w[-1].message))
def testAssertionErrorShouldDescribeExpectedAndActual(self): expected = 'EXPECTED' actual = 'ACTUAL' expectedMessage = "\nExpected: 'EXPECTED'\n but: was 'ACTUAL'\n" with self.assertRaises(AssertionError) as e: assert_that(actual, equal_to(expected)) self.assertEqual(expectedMessage, str(e.exception))
def testAssertionErrorShouldIncludeOptionalReason(self): expected = 'EXPECTED' actual = 'ACTUAL' expectedMessage = "REASON\nExpected: 'EXPECTED'\n but: was 'ACTUAL'\n" with self.assertRaises(AssertionError) as e: assert_that(actual, equal_to(expected), 'REASON') self.assertEqual(expectedMessage, str(e.exception))
def test_many_elements(): Box = xmlfied('box', foos=Many(Element(name='foo'))) box = Box(foos=['a', 'b', 'c']) assert_that(etree.tostring(box.toxml()), all_of( string_contains_in_order('<box>', '<foos>', '<foo>', 'a', '</foo>', '</foos>', '</box>'), string_contains_in_order('<box>', '<foos>', '<foo>', 'b', '</foo>', '</foos>', '</box>'), string_contains_in_order('<box>', '<foos>', '<foo>', 'c', '</foo>', '</foos>', '</box>'), ))
def test_view_resource(self): url = 'dummy' user = DummyUser() http_request = MagicMock(user=user, method='GET') response = self.handler(http_request, url) assert_that(response.status_code, equal_to(200)) assert_that(json.loads(response.content), equal_to({'name': 'dummy'}))
def test_query_system(): """ Performs a full system test, invoking a local instance of the H2 database. Set environment variable CI=true in continuous integration to skip. """ if os.environ.get('CI'): return result = H2WorldServiceHandler().query('SELECT * FROM country') assert_that(len(result.splitlines()), equal_to(241))
def testAssertionErrorShouldDescribeExpectedAndActual(self): expected = 'EXPECTED' actual = 'ACTUAL' expectedMessage = "\nExpected: 'EXPECTED'\n but: was 'ACTUAL'\n" try: assert_that(actual, equal_to(expected)) except AssertionError, e: self.assertEqual(expectedMessage, str(e)) return
def test_crud_resource_get_list(self): url = 'dummy' user = DummyUser() http_request = MagicMock(user=user, method='GET') response = self.handler(http_request, url) assert_that(response.status_code, equal_to(200)) assert_that(json.loads(response.content), equal_to( {"objects": [{"name": "dummy"}], "meta": {"total": 1, "limit": 20, "offset": 0}}))
def testAssertionErrorShouldIncludeOptionalReason(self): expected = 'EXPECTED' actual = 'ACTUAL' expectedMessage = "REASON\nExpected: 'EXPECTED'\n but: was 'ACTUAL'\n" try: assert_that(actual, equal_to(expected), 'REASON') except AssertionError, e: self.assertEqual(expectedMessage, str(e)) return
def test_expected_has_the_wrong_type(self): # Given not_a_schema = "Test" # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_schema(not_a_schema)) # Then self.assertEqual( str(ex.exception.message), 'Provided schema is not a StructType but <type \'str\'>' )
def test_has_the_wrong_schema(self): # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_schema(self.schema_1_field)) # Then self.assertEqual( str(ex.exception.message), assertion_error_message( 'Given DataFrame has schema %s' % self.schema_1_field, 'has schema %s' % self.schema_2_fields ) )
def test_has_the_wrong_count(self): # Given wrong_count = 1 # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_count(wrong_count)) # Then self.assertEqual( str(ex.exception.message), assertion_error_message('Given DataFrame has count 1', 'has count 2') )
def test_expected_has_the_wrong_type(self): # Given not_a_field = "Test" # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_schema_containing_field(not_a_field)) # Then self.assertEqual( str(ex.exception.message), 'Provided field is not a StructField but <type \'str\'>' )
def test_intermediate_output_is_face_from_die(self): facevalue1 = FaceValue(1, unit1) facevalue2 = FaceValue(1, unit2) die = Die("Test", Face(facevalue1, facevalue2), Face(facevalue1, facevalue2)) result = BaseRoller(die).roll() test_result = result.intermediateOutput assert_that(test_result, any_of( equal_to('[' + unit1(1) + ' | ' + unit2(1) + ']'), equal_to('[' + unit2(1) + ' | ' + unit1(1) + ']')))
def test_final_output_works_with_multiple_face_values(self): facevalue1 = FaceValue(1, unit1) facevalue2 = FaceValue(1, unit2) die = Die("Test", Face(facevalue1, facevalue2), Face(facevalue1, facevalue2)) result = BaseRoller(die).roll() test_result = result.finalOutput assert_that(test_result, any_of( equal_to(unit1(1) + ' | ' + unit2(1)), equal_to(unit2(1) + ' | ' + unit1(1))))
def test_has_the_wrong_type(self): # Given not_a_dataframe = "Test" # When with self.assertRaises(AssertionError) as ex: assert_that(not_a_dataframe, has_count(2)) # Then self.assertEqual( str(ex.exception.message), assertion_error_message('Given DataFrame has count 2', '<type \'str\'> is not a DataFrame') )
def test_expected_has_the_wrong_type(self): # Given not_a_count = "Test" # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_count(not_a_count)) # Then self.assertEqual( str(ex.exception.message), 'Provided count is not an int but <type \'str\'>' )
def test_cityLanguage_system(): """ Performs a full system test, invoking a local instance of the H2 database. Set environment variable CI=true in continuous integration to skip. """ if os.environ.get('CI'): return result = H2WorldServiceHandler().cityLanguage('Melbourne') assert_that(result, equal_to('English (81.2%)')) result = H2WorldServiceHandler().cityLanguage('Kandy') assert_that(result, equal_to('Singali (60.3%)'))
def test_elements_order(): Foo = xmlfied('foo', fields=[ ('bar', Element()), ('baz', Element()), ('gaz', Element()), ('daz', Element())]) foo = Foo(bar=3, baz=4, gaz=5, daz=6) assert_that(etree.tostring(foo.toxml()), string_contains_in_order( '<bar>', '3', '</bar>', '<baz>', '4', '</baz>', '<gaz>', '5', '</gaz>', '<daz>', '6', '</daz>' ))
def test_many_nested(): Item = xmlfied('item', value=Element()) Box = xmlfied('box', items=Many(Nested())) box = Box(items=[]) box.items.append(Item('a')) box.items.append(Item('a')) box.items.append(Item('a')) assert_that( etree.tostring(box.toxml()), all_of( string_contains_in_order('<box>', '<items>', '<item>', 'a', '</item>', '<item>', 'a', '</item>', '<item>', 'a', '</item>', '</items>', '</box>'), ))
def test_nested(): Top = xmlfied('top', foo=Nested()) Down = xmlfied('down', bar=Element(), baz=Attribute()) d = Down(bar='123', baz='456') t = Top(foo=d) assert_that(get_xml_string(t.toxml()), string_contains_in_order( '<top>', '<down', 'baz=', '"456"', '<bar>', '123', '</bar>', '</down>', '</top>' ))
def test_does_not_contain_the_field(self): # Given name = 'field2' data_type = StringType() not_in_dataframe_schema = StructField(name=name, dataType=data_type) # When with self.assertRaises(AssertionError) as ex: assert_that(self.df, has_schema_containing_field(not_in_dataframe_schema)) # Then self.assertEqual( str(ex.exception.message), assertion_error_message( 'Given DataFrame\'s schema contains %s of type %s' % (name, data_type), 'Schema only contains %s' % self.schema.names))
def test_cash_amount_changed_make_change(self) -> None: """Cash amount changed must balance with change given.""" drawer: CashDrawer = CashDrawer() total: float = drawer.get_total() drawer.open(187.91) cash_in: float = 200.0 drawer.add_count(CashDenomination.HUNDRED_DOLLAR_BILL, 2) cash_in -= 0.01 * 4 drawer.remove_count(CashDenomination.PENNY, 4) cash_in -= 0.05 * 1 drawer.remove_count(CashDenomination.NICKEL, 1) cash_in -= 1.0 * 1 drawer.remove_count(CashDenomination.DOLLAR_COIN, 1) cash_in -= 1.0 * 1 drawer.remove_count(CashDenomination.ONE_DOLLAR_BILL, 1) cash_in -= 10.0 * 1 drawer.remove_count(CashDenomination.TEN_DOLLAR_BILL, 1) assert_that(cash_in, close_to(187.91, 0.001)) try: drawer.close() assert_that(drawer.get_total(), close_to(total + 187.91, 0.001)) except Exception: pytest.fail("Unexpected Exception when closing drawer")
def assert_that_output_contains(self, substring, times=None): assert_that(self.owtf_output, contains_string(substring)) if times is not None: assert_that(self.owtf_output.count(substring), equal_to(times))
def test_approved(self) -> None: """Test Approved.""" assert_that(str(CardTransactionResult.APPROVED), is_("Approved"))
def test_read_error(self) -> None: """Test Card Read Error.""" assert_that(str(CardTransactionResult.READ_ERROR), is_("Card Read Error"))
def test_row_has_value(self): assert_that(Field('field1').of(self.row), has_value(42))
def test_incorrect_pin(self) -> None: """Test Approved.""" assert_that(str(CardTransactionResult.INCORRECT_PIN), is_("Incorrect PIN"))
def test_one_dollar_bill(self) -> None: """Test One Dollar Bill.""" assert_that(str(CashDenomination.ONE_DOLLAR_BILL), is_("$1 Bill")) assert_that(CashDenomination.ONE_DOLLAR_BILL.amount, close_to(1.0, 0.00001))
def test_open_drawer_amount_negative(self) -> None: """Open drawer amount must not be negative.""" drawer: CashDrawer = CashDrawer() with pytest.raises(ValueError) as e: drawer.open(-0.01) assert_that(str(e.value), is_("Amount must not be negative."))
def test_enum_size(self) -> None: """Test size of enum.""" assert_that(len(CashDenomination), is_(12))
def test_hundred_dollar_bill(self) -> None: """Test Hundred Dollar Bill.""" assert_that(str(CashDenomination.HUNDRED_DOLLAR_BILL), is_("$100 Bill")) assert_that(CashDenomination.HUNDRED_DOLLAR_BILL.amount, close_to(100.0, 0.00001))
def test_fifty_dollar_bill(self) -> None: """Test Fifty Dollar Bill.""" assert_that(str(CashDenomination.FIFTY_DOLLAR_BILL), is_("$50 Bill")) assert_that(CashDenomination.FIFTY_DOLLAR_BILL.amount, close_to(50.0, 0.00001))
def test_twenty_dollar_bill(self) -> None: """Test Twenty Dollar Bill.""" assert_that(str(CashDenomination.TWENTY_DOLLAR_BILL), is_("$20 Bill")) assert_that(CashDenomination.TWENTY_DOLLAR_BILL.amount, close_to(20.0, 0.00001))
def test_ten_dollar_bill(self) -> None: """Test Ten Dollar Bill.""" assert_that(str(CashDenomination.TEN_DOLLAR_BILL), is_("$10 Bill")) assert_that(CashDenomination.TEN_DOLLAR_BILL.amount, close_to(10.0, 0.00001))
def test_constructor_populates_drawer(self) -> None: """Test constructor.""" drawer: CashDrawer = CashDrawer() for denom in CashDenomination: assert_that(drawer.get_count(denom), is_(10))
def testCanTestBoolDirectly(self): assert_that(True, "should accept True") with self.assertRaises(AssertionError) as e: assert_that(False, "FAILURE REASON") self.assertEqual("FAILURE REASON", str(e.exception))
def testShouldBeSilentOnSuccessfulMatch(self): assert_that(1, equal_to(1))
def test_dollar_coin(self) -> None: """Test Dollar Coin.""" assert_that(str(CashDenomination.DOLLAR_COIN), is_("Dollar Coin")) assert_that(CashDenomination.DOLLAR_COIN.amount, close_to(1.0, 0.00001))
def test_declined(self) -> None: """Test Declined.""" assert_that(str(CardTransactionResult.DECLINED), is_("Declined"))
def test_penny(self) -> None: """Test Penny.""" assert_that(str(CashDenomination.PENNY), is_("Penny")) assert_that(CashDenomination.PENNY.amount, close_to(0.01, 0.00001))
def test_insufficient_funds(self) -> None: """Test Approved.""" assert_that(str(CardTransactionResult.INSUFFICIENT_FUNDS), is_("Insufficient Funds"))
def test_nickel(self) -> None: """Test Nickel.""" assert_that(str(CashDenomination.NICKEL), is_("Nickel")) assert_that(CashDenomination.NICKEL.amount, close_to(0.05, 0.00001))
def test_enum_size(self) -> None: """Test size of enum.""" assert_that(len(CardTransactionResult), is_(5))
def test_dime(self) -> None: """Test Dime.""" assert_that(str(CashDenomination.DIME), is_("Dime")) assert_that(CashDenomination.DIME.amount, close_to(0.10, 0.00001))
def testAssertionUnicodeEncodesProperly(self): expected = "EXPECTED" actual = u("\xdcnic\N{Latin Small Letter O with diaeresis}de") with self.assertRaises(AssertionError): assert_that(actual, equal_to(expected), "REASON")
def test_quarter(self) -> None: """Test Quarter.""" assert_that(str(CashDenomination.QUARTER), is_("Quarter")) assert_that(CashDenomination.QUARTER.amount, close_to(0.25, 0.00001))
def test_should_create_sentence_binding_from_morpheme_containers(self): morpheme_containers = [] morpheme_containers.append(self._get_word_morpheme_container_tuple(u'blablabla')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'Kitaba', u'kitap+Noun+A3sg+Pnon+Dat')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'abcabcabc')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'buyurmam')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'yetiştirdik')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'Kıvrandığın', u'kıvran+Verb+Pos+Adj+PastPart+P2sg')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'sabahçı')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u'sabah')) morpheme_containers.append(self._get_word_morpheme_container_tuple(u"Ali'nin")) sentence = self.parseset_creator.create_sentence_binding_from_morpheme_containers(morpheme_containers) expected = u''' <sentence> <unparsable_word str="blablabla"/> <word parse_result="kitap+Noun+A3sg+Pnon+Dat" str="Kitaba" syntactic_category="Noun"> <root lemma="kitap" lemma_root="kitap" str="kitab" syntactic_category="Noun"/> <suffixes> <inflectionalSuffix actual="" application="" form="" id="A3Sg_Noun" matched_word="kitab" name="A3sg" to_syntactic_category="Noun" word="kitap"/> <inflectionalSuffix actual="" application="" form="" id="Pnon_Noun" matched_word="kitab" name="Pnon" to_syntactic_category="Noun" word="kitap"/> <inflectionalSuffix actual="a" application="a" form="+yA" id="Dat_Noun" matched_word="kitaba" name="Dat" to_syntactic_category="Noun" word="kitaba"/> </suffixes> </word> <unparsable_word str="abcabcabc"/> <word parse_result="buyur+Verb+Neg+Aor+A1sg" str="buyurmam" syntactic_category="Verb"> <root lemma="buyurmak" lemma_root="buyur" str="buyur" syntactic_category="Verb"/> <suffixes> <inflectionalSuffix actual="ma" application="ma" form="mA" id="Neg" matched_word="buyurma" name="Neg" to_syntactic_category="Verb" word="buyurma"/> <inflectionalSuffix actual="" application="" form="" id="Aor" matched_word="buyurma" name="Aor" to_syntactic_category="Verb" word="buyurma"/> <inflectionalSuffix actual="m" application="m" form="+Im" id="A1Sg_Verb" matched_word="buyurmam" name="A1sg" to_syntactic_category="Verb" word="buyurmam"/> </suffixes> </word> <word parse_result="yetiş+Verb+Verb+Caus+Pos+Past+A1pl" str="yetiştirdik" syntactic_category="Verb"> <root lemma="yetişmek" lemma_root="yetiş" str="yetiş" syntactic_category="Verb"/> <suffixes> <derivationalSuffix actual="tir" application="tir" form="dIr" id="Caus" matched_word="yetiştir" name="Caus" to_syntactic_category="Verb" word="yetiştir"/> <inflectionalSuffix actual="" application="" form="" id="Pos" matched_word="yetiştir" name="Pos" to_syntactic_category="Verb" word="yetiştir"/> <inflectionalSuffix actual="di" application="di" form="dI" id="Past" matched_word="yetiştirdi" name="Past" to_syntactic_category="Verb" word="yetiştirdi"/> <inflectionalSuffix actual="k" application="k" form="k" id="A1Pl_Verb" matched_word="yetiştirdik" name="A1pl" to_syntactic_category="Verb" word="yetiştirdik"/> </suffixes> </word> <word parse_result="kıvran+Verb+Pos+Adj+PastPart+P2sg" str="Kıvrandığın" syntactic_category="Adj"> <root lemma="kıvranmak" lemma_root="kıvran" str="kıvran" syntactic_category="Verb"/> <suffixes> <inflectionalSuffix actual="" application="" form="" id="Pos" matched_word="kıvran" name="Pos" to_syntactic_category="Verb" word="kıvran"/> <derivationalSuffix actual="dığ" application="dık" form="dIk" id="PastPart_Adj" matched_word="kıvrandığ" name="PastPart" to_syntactic_category="Adj" word="kıvrandık"/> <inflectionalSuffix actual="ın" application="ın" form="+In" id="P2Sg_Adj" matched_word="kıvrandığın" name="P2sg" to_syntactic_category="Adj" word="kıvrandığın"/> </suffixes> </word> <word parse_result="sabah+Noun+Time+A3sg+Pnon+Nom+Adj+Agt" str="sabahçı" syntactic_category="Adj"> <root lemma="sabah" lemma_root="sabah" secondary_syntactic_category="Time" str="sabah" syntactic_category="Noun"/> <suffixes> <inflectionalSuffix actual="" application="" form="" id="A3Sg_Noun" matched_word="sabah" name="A3sg" to_syntactic_category="Noun" word="sabah"/> <inflectionalSuffix actual="" application="" form="" id="Pnon_Noun" matched_word="sabah" name="Pnon" to_syntactic_category="Noun" word="sabah"/> <inflectionalSuffix actual="" application="" form="" id="Nom_Deriv_Noun" matched_word="sabah" name="Nom" to_syntactic_category="Noun" word="sabah"/> <derivationalSuffix actual="çı" application="çı" form="cI" id="Agt_Noun_to_Adj" matched_word="sabahçı" name="Agt" to_syntactic_category="Adj" word="sabahçı"/> </suffixes> </word> <word parse_result="sabah+Adv+Time" secondary_syntactic_category="Time" str="sabah" syntactic_category="Adv"> <root lemma="sabah" lemma_root="sabah" secondary_syntactic_category="Time" str="sabah" syntactic_category="Adv"/> </word> <word parse_result="Ali+Noun+Prop+Apos+A3sg+Pnon+Gen" secondary_syntactic_category="Prop" str="Ali'nin" syntactic_category="Noun"> <root lemma="Ali" lemma_root="Ali" secondary_syntactic_category="Prop" str="Ali" syntactic_category="Noun"/> <suffixes> <inflectionalSuffix actual="'" application="'" form="'" id="Apos_Proper_Noun" matched_word="Ali'" name="Apos" to_syntactic_category="Noun" word="Ali'"/> <inflectionalSuffix actual="" application="" form="" id="A3Sg_Noun" matched_word="Ali'" name="A3sg" to_syntactic_category="Noun" word="Ali'"/> <inflectionalSuffix actual="" application="" form="" id="Pnon_Noun" matched_word="Ali'" name="Pnon" to_syntactic_category="Noun" word="Ali'"/> <inflectionalSuffix actual="nin" application="nin" form="+nIn" id="Gen_Noun" matched_word="Ali'nin" name="Gen" to_syntactic_category="Noun" word="Ali'nin"/> </suffixes> </word> </sentence> ''' expected = expected.strip() actual = sentence.to_dom().toprettyxml().strip() if expected!=actual: for line in context_diff(expected.split('\n'), actual.split('\n'), "expected", "actual"): print line assert_that(expected, equal_to(sentence.to_dom().toprettyxml().strip()))
def test_half_dollar(self) -> None: """Test Half Dollar.""" assert_that(str(CashDenomination.HALF_DOLLAR), is_("Half Dollar")) assert_that(CashDenomination.HALF_DOLLAR.amount, close_to(0.50, 0.00001))