def test_with_block_closes_runner_after_error(): with expect.raises(KeyError): with lola.Runner() as runner: raise KeyError() with expect.raises(ValueError): runner.close()
def test_dump_xearth_markers(): markers = { 500936: Trigpoint(52.066035, -0.281449, 37.000000, 'Broom Farm'), 501097: Trigpoint(52.010585, -0.173443, 97.000000, 'Bygrave'), 505392: Trigpoint(51.910886, -0.186462, 136.000000, 'Sish Lane') } data = dump_xearth_markers(markers) expect(data[0]) == '52.066035 -0.281449 "500936" # Broom Farm, alt 37m' expect(data[1]) == '52.010585 -0.173443 "501097" # Bygrave, alt 97m' expect(data[2]) == '51.910886 -0.186462 "505392" # Sish Lane, alt 136m' data = dump_xearth_markers(markers, 'name') expect(data[0]) == '52.066035 -0.281449 "Broom Farm" # 500936, alt 37m' expect(data[1]) == '52.010585 -0.173443 "Bygrave" # 501097, alt 97m' expect(data[2]) == '51.910886 -0.186462 "Sish Lane" # 505392, alt 136m' with expect.raises(ValueError, "Unknown name type 'falseKey'"): dump_xearth_markers(markers, 'falseKey') points = { 'Broom Farm': Point(52.066035, -0.281449), 'Bygrave': Point(52.010585, -0.173443), 'Sish Lane': Point(51.910886, -0.186462) } data = dump_xearth_markers(points) expect(data[0]) == '52.066035 -0.281449 "Broom Farm"' expect(data[1]) == '52.010585 -0.173443 "Bygrave"' expect(data[2]) == '51.910886 -0.186462 "Sish Lane"'
def it_ignores_new_attributes(obj, mapper): mapper.create() mapper.text = "var4: foo" mapper.load() with expect.raises(AttributeError): print(obj.var4)
def test_angle_to_distance(): expect('%.3f' % angle_to_distance(1)) == '111.125' expect('%i' % angle_to_distance(360, 'imperial')) == '24863' expect('%i' % angle_to_distance(1.0 / 60, 'nautical')) == '1' with expect.raises(ValueError, "Unknown units type 'baseless'"): '%i' % angle_to_distance(10, 'baseless')
def test_issues(self): title = 'Test issue for github3.py' with expect.raises(github3.GitHubError): # Try to create one without authenticating self.g.create_issue(self.sigm, self.todo, title) # Try to get individual ones self.g.issue(self.sigm, self.todo, 2000) self.g.list_user_issues() i = self.g.issue(self.sigm, self.todo, 1) self.assertIsNotNone(i) expect(i).isinstance(github3.issues.Issue) expect(i.list_comments()) != [] # Test listing issues list_issues = self.g.list_repo_issues expect(list_issues(self.kr, 'requests')) != [] expect(list_issues(self.sigm, self.todo)).isinstance(list) for f in ('assigned', 'created', 'mentioned'): self.assertIsNotNone(list_issues(self.sigm, self.todo, f)) for s in ('open', 'closed'): self.assertIsNotNone(list_issues(self.sigm, self.todo, state=s)) self.assertIsNotNone(list_issues(self.sigm, self.todo, state='closed', labels='Bug,Enhancement')) for s in ('created', 'updated', 'comments'): self.assertIsNotNone(list_issues(self.sigm, self.todo, sort=s)) for d in ('asc', 'desc'): self.assertIsNotNone(list_issues(self.sigm, self.todo, state='closed', direction=d)) self.assertIsNotNone(list_issues(self.sigm, self.todo, since='2011-01-01T00:00:01Z'))
def test_start_time_validity(string, expected): p = StartTimeParamType() if expected is True: expect(p.convert(string, None, None) == string) else: with expect.raises(expected): p.convert(string, None, None)
def test_signature_doesnt_verify(self): sp = Pysamlsp({ 'certificate': os.path.dirname(os.path.abspath(__file__)) + '/support/saml.crt' }) with expect.raises(): sp.verify_signature(TEST_NONSENSE_RESPONSE)
def should_enforce_time_moves_only_forward(self): async def first(clock, balances): yield 100, 'A', 'B', 'Meh' await clock.until(date(2010, 1,1)) sim = Simulation(first, start_date=date(2019, 6, 1), end_date=date(2030, 6, 1)) with expect.raises(InvalidWaitTime): sim.run()
def test_unsupported_comparision(): from sys import version_info repr_name = 'class' if version_info[0] >= 3 else 'type' with expect.raises(NotImplementedError, 'Unable to compare Version and ' "<%s 'float'>" % repr_name): float(3.2) == Version('0.2.0')
def should_enforce_cash_only_flows_between_with_registered_accounts(self): @assert_accounts('registered_acct') async def badly_written_generator(clock, balances): yield 100, 'registered_acct', 'forgotten_acct', 'should die because forgotten not registered' sim = Simulation(badly_written_generator, start_date=date(2019, 6, 1), end_date=date(2030, 6, 1)) with expect.raises(InvalidAccount): sim.run()
def test_fail_start_when_task_typo(): events = Events.read('tests/data/test_not_running') with expect.raises( TaskNotExistError, "Task non_existant does not exist! Use `--new' to " "create it"): events.start(task='non_existant')
def test_exit_with_failure(stdout): @exit('custom message') def f(x, y): raise ValueError('boom') with expect.raises(ValueError): f(4, 3) expect(stdout.getvalue()) == 'custom message\n'
def test_user_is_invalid(self): sp = Pysamlsp({ 'certificate': os.path.dirname(os.path.abspath(__file__)) + '/support/saml.crt' }) with expect.raises(SAMLNameIDError): sp.user_is_valid(TEST_NONSENSE_RESPONSE)
def test_gists(self): gists = self.g.list_gists() expect(gists) != [] for g in gists: expect(g).isinstance(Gist) expect(g.files) >= 0 expect(g.list_files()).isinstance(list) expect(g.forks) >= 0 self.assertAreNotNone(g, 'created_at', 'description', 'git_pull_url', 'git_push_url', 'html_url', 'id') expect(g.is_public()).isinstance(bool) expect(g.is_starred()).isinstance(bool) expect(g.to_json()).isinstance(dict) comments = g.list_comments() if comments: for c in comments: expect(c).isinstance(GistComment) expect(g.refresh()).isinstance(bool) expect(g.user).isinstance(User) with expect.raises(github3.GitHubError): g.create_comment('Foo') g.delete() g.edit() g.fork() g.star() g.unstar()
def test_task_name_validity(string, expected): p = TaskNameParamType() if expected is True: expect(p.convert(string, None, None) == string) else: with expect.raises(expected): p.convert(string, None, None)
def test_blob(self): r = self.todor blob = r.blob("f737918b90118a6aea991f89f444b150a2360393") expect(blob).isinstance(Blob) self.assertAreNotNone(blob, "content", "decoded", "encoding", "sha", "size") with expect.raises(github3.GitHubError): r.create_blob("Foo bar bogus", "utf-8")
def test___init__(self): test = Point(math.pi / 4, math.pi / 2, angle='radians') expect(test.latitude) == 45 expect(test.longitude) == 90 test = Point((50, 20, 10), (-1, -3, -12)) expect('%.3f' % test.latitude) == '50.336' expect('%.3f' % test.longitude) == '-1.053' with expect.raises(ValueError, 'Unknown angle type None'): Point(52.015, -0.221, angle=None) with expect.raises(ValueError, 'Invalid latitude value -92'): Point(-92, -0.221) with expect.raises(ValueError, 'Invalid longitude value 185'): Point(52.015, 185) with expect.raises(ValueError, 'Unknown units type None'): Point(52.015, -0.221, units=None)
def test_call_with_closed_runner_throws_error(): runner = lola.Runner() runner.close() with expect.raises(ValueError): runner.call(['test_scripts/success.py'], stdout=DEVNULL, stderr=DEVNULL)
def it_allows_only_attributes_listed_in__slots__to_be_assigned(self): class Eggs(object): __slots__ = ["spam"] eggs = Eggs() eggs.spam = True with expect.raises(AttributeError): eggs.bacon = True
def test_requires_auth(self): with expect.raises(github3.GitHubError): for g in self.gists: g.create_comment('Foo') g.delete() g.edit() g.fork() g.star() g.unstar()
def should_enforce_only_registered_accounts_are_accessed(self): @assert_accounts('registered_acct1', 'registered_acct2') async def badly_written_generator(clock, balances): balances['registered_acct1'] balances['forgotten_acct'] yield 100, 'registered_acct1', 'registered_acct2', 'Should not get this far' sim = Simulation(badly_written_generator, start_date=date(2019, 6, 1), end_date=date(2030, 6, 1)) with expect.raises(InvalidAccount): sim.run()
def should_be_able_to_manually_set_ids_only_while_clock_not_started(self): Synapse.clock.reset() neuron = Neuron(id=3) expect(neuron.id) == 3 expect(Synapse(neuron, 10, id=7).id) == 7 Synapse.clock.start() expect(Neuron().id) == 8 with expect.raises(AssertionError): Neuron(id=3)
def test_refs(self): r = self.todor ref = r.ref("heads/development") expect(ref).isinstance(Reference) self.assertAreNotNone(ref, "object", "ref") with expect.raises(github3.GitHubError): ref.delete() ref.update("31e862095dffa60744f1ce16a431ea040381f053")
def should_enforce_generators_await_clock(self): # doesn't work because call to async wait method without await means it won't be run # is there a way to see which futures are doing nothing and assert failure? async def badly_written_generator(clock, balances): yield 100, 'A', 'B', 'ok' clock.tick(years=1) yield 100, 'A', 'B', 'ok' sim = Simulation(badly_written_generator, start_date=date(2019, 6, 1), end_date=date(2030, 6, 1)) with expect.raises(FailedToAwaitClock): sim.run()
def test___repr__(self): expect(repr(Baken(14.460, 20.680, None, None, None, 0.000, None, None, None, None, None))) == \ 'Baken(14.46, 20.68, None, None, None, 0.0, None, None, None, None, None)' expect(repr(Baken(None, None, '2 x Turnstile', None, 50.000, 460.000, 'IO93BF', 'A1A', None, 25, None))) == \ ("Baken(%s, -1.875, '2 x Turnstile', None, 50.0, " "460.0, 'IO93BF', 'A1A', None, 25, None)" % 53.229166666666686) with expect.raises(LookupError, ('Unable to instantiate baken object, no latitude ' 'or locator string')): Baken(None, None)
def test_watching(self): expect(self.g.list_watching(self.sigm)) != [] with expect.raises(github3.GitHubError): self.g.watch(self.sigm, self.todo) self.g.unwatch(self.sigm, self.todo) self.g.list_watching() self.g.is_watching(self.sigm, self.todo) if self.auth: expect(self._g.watch(self.sigm, self.todo)).isinstance(bool) expect(self._g.unwatch(self.sigm, self.todo)).isinstance(bool) expect(self._g.list_watching()) != [] expect(self._g.is_watching(self.sigm, self.todo)) != []
def test_import_locations(self): locations = Locations(open('tests/data/geonames')) expect(str(locations[0])) == \ 'Afon Wyre (River Wayrai, River Wyrai, Wyre - N52.317°; W004.167°)' expect(str(locations[1])) == \ 'Wyre (Viera - N59.117°; W002.967°)' expect(str(locations[2])) == \ 'Wraysbury (Wyrardisbury - N51.450°; W000.550°)' with expect.raises(FileFormatError, "Incorrect data format, if you're using a file " 'downloaded from geonames.org please report this ' 'to James Rowe <*****@*****.**>'): Locations(open('tests/data/broken_geonames'))
def test_import_timezones_file(self): locations = Locations(None, open('tests/data/geonames_timezones')) timezones = locations.timezones expect(timezones['Asia/Dubai']) == [240, 240] expect(timezones['Asia/Kabul']) == [270, 270] expect(timezones['Europe/Andorra']) == [60, 120] header_skip_check = Locations(None, open('tests/data/geonames_timezones_header')) expect(header_skip_check) == Locations() with expect.raises(FileFormatError, "Incorrect data format, if you're using a file " 'downloaded from geonames.org please report this ' 'to James Rowe <*****@*****.**>'): Locations(None, open('tests/data/geonames_timezones_broken'))
def test_following(self): expect(self.g.list_followers('kennethreitz')) != [] expect(self.g.list_following('kennethreitz')) != [] with expect.raises(github3.GitHubError): self.g.is_following(self.sigm) self.g.follow(self.sigm) self.g.unfollow(self.sigm) self.g.list_followers() self.g.list_following() if self.auth: expect(self._g.is_following(self.sigm)).isinstance(bool) expect(self._g.follow(self.sigm)).isinstance(bool) expect(self._g.unfollow(self.sigm)).isinstance(bool) expect(self._g.list_followers()) != [] expect(self._g.list_following()) != []
def it_raises_exception_when_they_decrease(project2): project2.update(dict(unit=5)) with expect.raises(ValueError): project2.update(dict(unit=4)) expect(project2.metrics) == dict( current=dict( unit=4.0, integration=3.4, overall=5.6, ), minimum=dict( unit=5.0, integration=3.4, overall=5.6, ), )
def test_login(self): # Test "regular" auth self.g.login(*self.fake_auth) h = github3.login(*self.fake_auth) for i in [self.g, h]: expect(self.fake_auth) == i._session.auth # Test "oauth" auth self.g.login(token=self.fake_oauth) h = github3.login('', '', token=self.fake_oauth) for i in [self.g, h]: expect(i._session.headers['Authorization']) == 'token ' +\ self.fake_oauth with expect.raises(github3.GitHubError): self.g.user() if self.auth: self.assertIsNotNone(self._g.user())
def test_distance(self): home = Point(52.015, -0.221) dest = Point(52.6333, -2.5) expect('%i kM' % home.distance(dest)) == '169 kM' expect('%i kM' % home.distance(dest, method='sloc')) == '169 kM' with expect.raises(ValueError, "Unknown method type 'Invalid'"): home.distance(dest, method='Invalid') start = Point(36.1200, -86.6700) dest = Point(33.9400, -118.4000) expect('%i kM' % start.distance(dest)) == '2884 kM' start.units = 'imperial' expect('%i mi' % start.distance(dest)) == '1792 mi' start.units = 'nautical' expect('%i nmi' % start.distance(dest)) == '1557 nmi' start.units = 'metric' expect('%i kM' % start.distance(dest, method='sloc')) == '2884 kM'
def test_files(self): ninjax = self.g.gist(3156487) # An gist I used for someone in ##python on freenode. I promise not to update it further expect(ninjax.files) == 2 coms = ninjax.list_comments() if coms: for c in coms: expect(c).isinstance(GistComment) self.assertAreNotNone(c, 'body', 'body_html', 'body_text', 'created_at', 'id', 'user') with expect.raises(github3.GitHubError): c.delete() c.edit('foo') files = ninjax.list_files() expect(files) != [] for f in files: expect(f).isinstance(GistFile) self.assertAreNotNone(f, 'content', 'name', 'lang', 'raw_url', 'size')
def test_from_iso6709_location_page(): # The following tests are from the Latitude, Longitude and Altitude format # for geospatial information page # (http://www.w3.org/2005/Incubator/geo/Wiki/LatitudeLongitudeAltitude) # Mount Everest expect(from_iso6709('+27.5916+086.5640+8850/')) == \ (27.5916, 86.564, 8850.0) # South Pole expect(from_iso6709('-90+000+2800/')) == (-90.0, 0.0, 2800.0) # New York City expect(from_iso6709('+40.75-074.00/')) == (40.75, -74.0, None) # Mount Fuji expect(from_iso6709('+352139+1384339+3776/')) == \ (35.36083333333333, 138.7275, 3776.0) # Tokyo Tower expect(from_iso6709('+35.658632+139.745411/')) == \ (35.658632, 139.745411, None) with expect.raises(ValueError, "Incorrect format for longitude '+1'"): from_iso6709('+35.658632+1/')
def test_gists(self): # My gcd example gist_id = 2648112 if not self.g.gist(gist_id): self.fail('Check gcd gist') with expect.raises(github3.GitHubError): self.g.gist(-1) for i in None, self.sigm: expect(self.g.list_gists(i)) != [] if self.auth: desc = 'Testing gist creation' files = {'test.txt': {'content': 'Test contents'}} gist = self._g.create_gist(desc, files, False) self.assertIsNotNone(gist) expect(gist.description) == desc expect(gist.is_public()) == False for g in gist.files: expect(g.content) == files[g.name]['content'] expect(gist.delete()) == True
def test_starting_zibrato_with_an_invalid__socket(self): with expect.raises(zmq.ZMQError): z1 = Zibrato(host='nowhere') del z1
def it_raises_an_exception_after_delete(mapper): mapper.delete() with expect.raises(exceptions.DeletedFileError): mapper.load()
def when_missing(config): with expect.raises(RuntimeError): find_config()
def it_requires_files_to_not_yet_exist(model_class, instance): instance.__mapper__.create() with expect.raises(exceptions.DuplicateMappingError): utilities.create(model_class, 'foo', 'bar')
def it_raises_an_exception_when_platform_is_unknown(): with expect.raises(RuntimeError): system.launch(None)
def test__isbn_cleanse_invalid(isbn, message): with expect.raises(IsbnError, message): _isbn_cleanse(isbn)
def when_unknown_color(): with expect.raises(AssertionError): common.style("_foo_", 'bar', _color_support=True)
def it_requries_color_with_messages(): with expect.raises(AssertionError): common.show("Hello, world!", 'foobar')
def should_check_only_valid_cashflows_yielded(self): async def badly_written_generator(clock, balances): yield 100, 'A', 'B' # forgot desc sim = Simulation(badly_written_generator, start_date=date(2019, 6, 1), end_date=date(2030, 6, 1)) with expect.raises(InvalidCashFlowYielded): sim.run()
def it_cannot_be_used_directly(): with expect.raises(NotImplementedError): SortedList.to_value(None) with expect.raises(NotImplementedError): SortedList.to_data(None)
def it_requires_a_mapped_instance(): with expect.raises(TypeError): utilities.load(Mock)
def it_is_not_yet_implemented(): with expect.raises(NotImplementedError): utilities.match(Mock)
def it_requires_a_mapped_class_or_instance(): with expect.raises(TypeError): utilities.find(Mock)
def it_raises_an_exception_when_unable_to_convert(): with expect.raises(ValueError): Integer.to_value("abc")
def it_cannot_be_used_directly(): with expect.raises(NotImplementedError): AttributeDictionary.to_value(None) with expect.raises(NotImplementedError): AttributeDictionary.to_data(None)
def test_custom_init_is_invoked(sample): sample.__mapper__.text = "var5:\n checked: 42" with expect.raises(RuntimeError): print(sample.var5)
def it_exits_when_no_config_found(tmpdir): tmpdir.chdir() with expect.raises(SystemExit): cli.main(['edit'])
def test__isbn_cleanse_invalid_length(checksum, message): with expect.raises(IsbnError, message): _isbn_cleanse('0-123', checksum=checksum)
def it_rejects_zero_arguments(): with expect.raises(ValueError): decorators.attr()
def test_convert_invalid(): with expect.raises(IsbnError, 'Only ISBN-13s with 978 Bookland code can be converted ' 'to ISBN-10.'): convert('0000000000000')
def it_rejects_more_than_one_argument(): with expect.raises(ValueError): decorators.attr(foo=1, bar=2)
def it_cannot_be_subclassed_without_a_type(): with expect.raises(NotImplementedError): UnknownSortedList.to_value(None) with expect.raises(NotImplementedError): UnknownSortedList.to_data(None)
def it_expects_the_file_to_not_be_deleted(instance): instance.__mapper__.delete() with expect.raises(exceptions.DeletedFileError): utilities.save(instance)