class TestPtBR(unittest.TestCase):
def setUp(self):
self.factory = Faker('pt_BR')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'VitóriaMagalhães',
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'vitoriamagalhaes'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'JoãoSimões',
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'joaosimoes'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'AndréCauã',
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'andrecaua'
class TestPtBR(unittest.TestCase):
def setUp(self):
self.factory = Faker('pt_BR')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'VitóriaMagalhães',
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email)
assert email.split('@')[0] == 'vitoriamagalhaes'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'JoãoSimões',
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email)
assert email.split('@')[0] == 'joaosimoes'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'AndréCauã',
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email)
assert email.split('@')[0] == 'andrecaua'
class TestArAa(unittest.TestCase):
def setUp(self):
self.factory = Faker('ar_AA')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'asyl'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'asyl'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email, check_deliverability=False)
assert email.split('@')[0] == 'asyl'
class TestNlNl(unittest.TestCase):
def setUp(self):
self.factory = Faker('nl_NL')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné',
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email)
assert email.split('@')[0] == 'fabienne'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné',
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email)
assert email.split('@')[0] == 'fabienne'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné',
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email)
assert email.split('@')[0] == 'fabienne'
class TestArAa(unittest.TestCase):
def setUp(self):
self.factory = Faker('ar_AA')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email)
assert email.split('@')[0] == 'asyl'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email)
assert email.split('@')[0] == 'asyl'
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'اصيل',
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email)
assert email.split('@')[0] == 'asyl'
class TestWework:
def setup_class(self):
corpid = "XXXXXXXXXXXXXXXXXXXXXXXXX"
contact_corpsecret = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
self.fake = Faker(locale='zh_CN')
self.wework = User_API()
self.wework.get_access_token(corpid,contact_corpsecret)
self.department = department_API()
self.department.get_access_token(corpid,contact_corpsecret)
def test_Adduesr(self):
userid = self.fake.user_name()
name = self.fake.name()
mobile = "+86 "+ self.fake.phone_number()
department =[self.department.get_department().json()['department'][-1]['id']]
email = self.fake.ascii_company_email()
print(f"userid:{userid},name:{name},mobile:{mobile},department:{department},email:{email}")
e = self.wework.create_User(userid,name,mobile,department=[4],email=email)
print(e.json())
assert e.json()["errcode"] == 0
def test_delUser(self):
print(self.department.get_department().json())
userid = self.department.get_department_uesr().json()["userlist"][0]["userid"]
print(userid)
a = self.wework.del_User(userid)
assert a.json()["errcode"] == 0
assert userid not in json.dumps(self.department.get_department_uesr().json(), indent=2, ensure_ascii=False)
class TestNlNl(unittest.TestCase):
def setUp(self):
self.factory = Faker('nl_NL')
self.provider = self.factory.provider('faker.providers.internet')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné'
)
def test_ascii_safe_email(self):
email = self.factory.ascii_safe_email()
validate_email(email, check_deliverability=False)
self.assertEqual(email.split('@')[0], 'fabienne')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné'
)
def test_ascii_free_email(self):
email = self.factory.ascii_free_email()
validate_email(email, check_deliverability=False)
self.assertEqual(email.split('@')[0], 'fabienne')
@mock.patch(
'faker.providers.internet.Provider.user_name',
lambda x: 'fabiënné'
)
def test_ascii_company_email(self):
email = self.factory.ascii_company_email()
validate_email(email, check_deliverability=False)
self.assertEqual(email.split('@')[0], 'fabienne')
def generate_users(quantity: int) -> str:
fake = Faker(['en_US', 'ru_RU', 'uk_UA'])
users = ''
for _ in range(quantity):
users = users + '<b>' + fake.first_name(
) + '</b> ' + fake.ascii_company_email() + '<br/>'
return users
def handle(self, *args, **options):
before_c_user = NewUser.objects.all().count()
before_c_ins = Institution.objects.all().count()
before_c_cat = Category.objects.all().count()
before_c_don = Donation.objects.all().count()
fake = Faker(['pl_PL'])
for _ in range(15):
x = fake.first_name()
User.objects.create_user(first_name=x,
password=x,
email=fake.ascii_company_email())
for _ in range(random.randint(10, 20)):
cat = Category.objects.create(name=fake.word())
cat.save()
for _ in range(random.randint(5, 15)):
ins = Institution.objects.create(
name=fake.domain_name(),
description=fake.text(max_nb_chars=80),
type=random.randint(1, 3))
ins.save()
for _ in range(random.randint(3, 6)):
cat = Category.objects.all().order_by('?')[0]
ins.categories.add(cat)
for _ in range(random.randint(80, 100)):
user = NewUser.objects.all().order_by('?')[0]
ins = Institution.objects.all().order_by('?')[0]
cat = Category.objects.all().order_by('?')[0]
d = Donation.objects.create(
quantity=random.randint(1, 50),
institution=ins,
address=fake.street_address(),
phone_number=random.randint(222222222, 999999999),
city=fake.city(),
zip_code=fake.postcode(),
pick_up_date=fake.date(),
pick_up_time=random.randint(0, 1449),
pick_up_comment=fake.text(max_nb_chars=40),
user=user)
d.save()
d.categories.add(cat)
after_c_user = NewUser.objects.all().count()
after_c_ins = Institution.objects.all().count()
after_c_cat = Category.objects.all().count()
after_c_don = Donation.objects.all().count()
self.stdout.write(self.style.SUCCESS('Wypełnienie bazy pomyślne:'))
self.stdout.write(
self.style.SUCCESS(f'User: {before_c_user} -> {after_c_user}'))
self.stdout.write(
self.style.SUCCESS(
f'Institution: {before_c_ins} -> {after_c_ins}'))
self.stdout.write(
self.style.SUCCESS(f'Category: {before_c_cat} -> {after_c_cat}'))
self.stdout.write(
self.style.SUCCESS(f'Donation: {before_c_don} -> {after_c_don}'))
print(fake.unix_partition())
print("providers.geo".center(100,"="))
print(fake.coordinate())
print(fake.latitude())
print(fake.latlng())
print(fake.local_latlng())
print(fake.location_on_land())
print(fake.longitude())
print("providers.internet".center(100,"="))
print(fake.ascii_company_email())
print(fake.ascii_email())
print(fake.ascii_free_email())
print(fake.ascii_safe_email())
print(fake.company_email())
print(fake.dga())
print(fake.domain_name())
print(fake.domain_word())
print(fake.email())
print(fake.free_email())
print(fake.free_email_domain())
print(fake.hostname())
print(fake.http_method())
print(fake.image_url())
print(fake.ipv4())
print(fake.ipv4_network_class())
class TrackerTest(unittest.TestCase):
def setUp(self):
self.apiUrl = "http://localhost:3002/api"
self.fake = Faker()
self.setUserObject()
self.customTimeline = {
"category": "cart",
"type": "info",
"content": {
"message": "test-content"
}
}
try:
# create user
createdUser = self.apiRequest(self.apiUrl + "/user/signup",
self.user, {})
# get token and project
token = createdUser["tokens"]["jwtAccessToken"]
self.header = {"Authorization": "Basic " + token}
self.project = createdUser["project"]
# create a component
component = {"name": self.fake.word()}
createdComponent = self.apiRequest(
self.apiUrl + "/component/" + self.project["_id"],
component,
self.header,
)
self.component = createdComponent
# create an errorTracker and set it as the global error tracker.
errorTracker = {"name": self.fake.word()}
createdErrorTracker = self.apiRequest(
self.apiUrl + "/error-tracker/" + self.project["_id"] + "/" +
createdComponent["_id"] + "/create",
errorTracker,
self.header,
)
self.errorTracker = createdErrorTracker
except requests.exceptions.HTTPError as error:
print(
"Couldnt create an error tracker to run a test, Error occured: "
)
print(error)
def setUserObject(self):
self.user = {
"name": self.fake.name(),
"password": "******",
"confirmPassword": "******",
"email": self.fake.ascii_company_email(),
"companyName": self.fake.company(),
"jobRole": self.fake.job(),
"companySize": self.fake.random_int(),
"card": {
"stripeToken": "tok_visa"
},
"subscription": {
"stripePlanId": 0
},
"cardName": self.fake.credit_card_provider(),
"cardNumber": self.fake.credit_card_number(),
"cvv": self.fake.credit_card_security_code(),
"expiry": self.fake.credit_card_expire(),
"city": self.fake.city(),
"state": self.fake.country(),
"zipCode": self.fake.postcode(),
"companyRole": self.fake.job(),
"companyPhoneNumber": self.fake.phone_number(),
"planId": "plan_GoWIYiX2L8hwzx",
"reference": "Github",
}
return self
def apiRequest(self, url, body, headers):
response = requests.post(url, body, headers=headers)
return response.json()
def test_should_take_in_custom_timeline_event(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
timeline = tracker.getTimeline()
self.assertIsInstance(timeline, list)
self.assertEqual(1, len(timeline))
self.assertEqual(self.customTimeline["category"],
timeline[0]["category"])
def test_should_ensure_timeline_event_contains_eventId_and_timestamp(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
timeline = tracker.getTimeline()
self.assertIsInstance(timeline[0]["eventId"], str)
self.assertIsInstance(timeline[0]["timestamp"], str)
def test_should_ensure_different_timeline_event_have_the_same_eventId(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"], "error")
timeline = tracker.getTimeline()
self.assertEqual(2, len(timeline)) # two timeline events
self.assertEqual(
timeline[0]["eventId"], timeline[1]["eventId"]
) # their eventId is the same, till there is an error sent to the server
def test_should_ensure_max_timline_cant_be_set_as_a_negative_number(self):
options = {"maxTimeline": -5}
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"], options)
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"], "error")
timeline = tracker.getTimeline()
self.assertEqual(2, len(timeline)) # two timeline events
def test_should_ensure_new_timeline_event_after_max_timeline_are_discarded(
self):
options = {"maxTimeline": 2}
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"], options)
customTimeline2 = {
"category": "logout",
"type": "success",
"content": {
"message": "tester"
}
}
# add 3 timeline events
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
tracker.addToTimeline(customTimeline2["category"],
customTimeline2["content"],
customTimeline2["type"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"], "debug")
timeline = tracker.getTimeline()
self.assertEqual(options["maxTimeline"],
len(timeline)) # three timeline events
self.assertEqual(timeline[0]["type"], self.customTimeline["type"])
self.assertEqual(timeline[1]["category"], customTimeline2["category"])
def test_should_add_tags(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tag = {"key": "location", "value": "Warsaw"}
tracker.setTag(tag['key'], tag['value'])
availableTags = tracker.getTags()
self.assertIsInstance(availableTags, list)
self.assertEqual(1, len(availableTags))
self.assertEqual(tag['key'], availableTags[0]['key'])
def test_should_add_multiple_tags(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tags = []
tag = {"key": "location", "value": "Warsaw"}
tags.append(tag)
tagB = {"key": "city", "value": "Leeds"}
tags.append(tagB)
tagC = {"key": "device", "value": "iPhone"}
tags.append(tagC)
tracker.setTags(tags)
availableTags = tracker.getTags()
self.assertIsInstance(availableTags, list)
self.assertEqual(len(tags), len(availableTags))
def test_should_overwrite_existing_keys_to_avoid_duplicate_tags(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tags = []
tag = {"key": "location", "value": "Warsaw"}
tags.append(tag)
tagB = {"key": "city", "value": "Leeds"}
tags.append(tagB)
tagC = {"key": "location", "value": "Paris"}
tags.append(tagC)
tagD = {"key": "device", "value": "iPhone"}
tags.append(tagD)
tagE = {"key": "location", "value": "London"}
tags.append(tagE)
tracker.setTags(tags)
availableTags = tracker.getTags()
self.assertIsInstance(availableTags, list)
self.assertEqual(3, len(availableTags)) # only 3 unique tags
self.assertEqual(tagC["key"], availableTags[0]["key"])
self.assertNotEqual(
tagC["value"],
availableTags[0]["value"]) # old value for that tag location
self.assertEqual(tagE["key"], availableTags[0]["key"])
self.assertEqual(
tagE["value"],
availableTags[0]["value"]) # latest value for that tag location
def test_should_create_fingerprint_as_message_for_error_capture_without_any_fingerprint(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = "Uncaught Exception"
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertEqual(event["fingerprint"][0], errorMessage)
def test_should_use_defined_fingerprint_array_for_error_capture_with_fingerprint(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
fingerprints = ['custom', 'errors']
tracker.setFingerPrint(fingerprints)
errorMessage = 'Uncaught Exception'
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertEqual(event["fingerprint"][0], fingerprints[0])
self.assertEqual(event["fingerprint"][1], fingerprints[1])
def test_should_use_defined_fingerprint_string_for_error_capture_with_fingerprint(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
fingerprint = 'custom-fingerprint'
tracker.setFingerPrint(fingerprint)
errorMessage = 'Uncaught Exception'
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertEqual(event["fingerprint"][0], fingerprint)
def test_should_create_an_event_ready_for_the_server_using_capture_message(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = 'This is a test'
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertEqual(event["type"], "message")
self.assertEqual(event["exception"]["message"], errorMessage)
def test_should_create_an_event_ready_for_the_server_while_having_the_timeline_with_same_event_id(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
errorMessage = 'This is a test'
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertEqual(2, len(event["timeline"]))
self.assertEqual(event["eventId"], event["timeline"][0]["eventId"])
self.assertEqual(event["exception"]["message"], errorMessage)
def test_should_create_an_event_ready_for_the_server_using_capture_exception(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = 'Error Found'
tracker.captureException(Exception(errorMessage))
event = tracker.getCurrentEvent()
self.assertEqual(event["type"], 'exception')
self.assertEqual(event["exception"]["message"], errorMessage)
def test_should_create_an_event_with_array_of_stacktrace(self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorType = 'ZeroDivisionError'
try:
divByZero = 1 / 0
except Exception as ex:
tracker.captureException(ex)
event = tracker.getCurrentEvent()
self.assertEqual(event["type"], 'exception')
self.assertEqual(event["exception"]["type"], errorType)
self.assertIsInstance(event["exception"]["stacktrace"], dict)
self.assertIsInstance(event["exception"]["stacktrace"]["frames"], list)
def test_should_create_an_event_with_the_object_of_the_stacktrace_in_place(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorType = 'ZeroDivisionError'
try:
divByZero = 1 / 0
except Exception as ex:
tracker.captureException(ex)
event = tracker.getCurrentEvent()
frame = event["exception"]["stacktrace"]["frames"][0]
self.assertIn("methodName", frame)
self.assertIn("lineNumber", frame)
self.assertIn("fileName", frame)
def test_should_create_an_event_and_new_event_should_have_different_id(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = 'division by zero'
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
event = tracker.captureMessage(errorMessage)
# event = tracker.getCurrentEvent()
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
newEvent = None
errorType = 'division by zero'
try:
divByZero = 1 / 0
except Exception as ex:
newEvent = tracker.captureException(ex)
# newEvent = tracker.getCurrentEvent()
# ensure that the first event have a type message, same error message
self.assertEqual(event["type"], 'message')
self.assertEqual(event["content"]["message"], errorMessage)
# ensure that the second event have a type exception, same error message
self.assertEqual(newEvent["type"], 'exception')
self.assertEqual(newEvent["content"]["message"], errorMessage)
# confim their eventId is different
self.assertNotEqual(event["_id"], newEvent["_id"])
def test_should_create_an_event_that_has_timeline_and_new_event_having_timeline_and_tags(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = 'division by zero'
errorMessageObj = 'division by zero'
# add timeline to first tracker
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
event = tracker.captureMessage(errorMessage)
# event = tracker.getCurrentEvent()
# add timeline and tag to second tracker
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
tag = {"key": "location", "value": "Warsaw"}
tracker.setTag(tag['key'], tag['value'])
newEvent = None
try:
divByZero = 1 / 0
except Exception as ex:
newEvent = tracker.captureException(ex)
# newEvent = tracker.getCurrentEvent()
# ensure that the first event have a type message, same error message and two timeline (one custom, one generic)
self.assertEqual(event["type"], 'message')
self.assertEqual(event["content"]["message"], errorMessage)
self.assertEqual(len(event["timeline"]), 2)
self.assertEqual(len(event["tags"]), 1) # the default event tag added
# ensure that the second event have a type exception, same error message and 2 tags
self.assertEqual(newEvent["type"], 'exception')
self.assertEqual(newEvent["content"]["message"], errorMessageObj)
self.assertEqual(len(newEvent["timeline"]), 2)
self.assertEqual(len(newEvent["tags"]),
2) # the default and custom tag
def test_should_contain_version_number_and_sdk_name_in_captured_message(
self):
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"])
errorMessage = 'Error Found'
tracker.captureMessage(errorMessage)
event = tracker.getCurrentEvent()
self.assertIsInstance(event['sdk']['name'], str)
self.assertGreaterEqual(
event['sdk']['version'], r'/(([0-9])+\.([0-9])+\.([0-9])+)/'
) # confirm that the version follows the pattern XX.XX.XX where X is a non negative integer
def test_should_add_code_capture_to_stack_trace_when_flag_is_passed_in_options(
self):
options = {"captureCodeSnippet": True}
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"], options)
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
event = None
errorType = 'ZeroDivisionError'
try:
divByZero = 1 / 0
except Exception as ex:
event = tracker.captureException(ex)
# event = tracker.getCurrentEvent()
self.assertEqual(event["type"], 'exception')
self.assertEqual(event["content"]["type"], errorType)
self.assertIsInstance(event["content"]["stacktrace"], dict)
self.assertIsInstance(event["content"]["stacktrace"]["frames"], list)
incidentFrame = event["content"]["stacktrace"]["frames"][0]
self.assertIn('linesBeforeError', incidentFrame)
self.assertIn('linesAfterError', incidentFrame)
self.assertIn('errorLine', incidentFrame)
def test_should_not_add_code_capture_to_stack_trace_when_flag_is_passed_in_options(
self):
options = {"captureCodeSnippet": False}
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"], options)
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
event = None
errorType = 'ZeroDivisionError'
try:
divByZero = 1 / 0
except Exception as ex:
event = tracker.captureException(ex)
# event = tracker.getCurrentEvent()
self.assertEqual(event["type"], 'exception')
self.assertEqual(event["content"]["type"], errorType)
self.assertIsInstance(event["content"]["stacktrace"], dict)
self.assertIsInstance(event["content"]["stacktrace"]["frames"], list)
incidentFrame = event["content"]["stacktrace"]["frames"][0]
self.assertNotIn('linesBeforeError', incidentFrame)
self.assertNotIn('linesAfterError', incidentFrame)
self.assertNotIn('errorLine', incidentFrame)
def test_should_add_code_capture_to_stack_trace_by_default_when_unwanted_flag_is_passed_in_options(
self):
options = {
"captureCodeSnippet":
"hello" # sdk expects a true or false but it defaults to true if wrong value is sent
}
tracker = FyipeTracker(self.apiUrl, self.errorTracker["_id"],
self.errorTracker["key"], options)
tracker.addToTimeline(self.customTimeline["category"],
self.customTimeline["content"],
self.customTimeline["type"])
event = None
errorType = 'ZeroDivisionError'
try:
divByZero = 1 / 0
except Exception as ex:
event = tracker.captureException(ex)
# event = tracker.getCurrentEvent()
self.assertEqual(event["type"], 'exception')
self.assertEqual(event["content"]["type"], errorType)
self.assertIsInstance(event["content"]["stacktrace"], dict)
self.assertIsInstance(event["content"]["stacktrace"]["frames"], list)
incidentFrame = event["content"]["stacktrace"]["frames"][0]
self.assertIn('linesBeforeError', incidentFrame)
self.assertIn('linesAfterError', incidentFrame)
self.assertIn('errorLine', incidentFrame)
class LoggerTest(unittest.TestCase):
def setUp(self):
self.apiUrl = "http://localhost:3002/api"
self.fake = Faker()
self.setUserObject()
try:
# create user
createdUser = self.apiRequest(self.apiUrl + "/user/signup", self.user, {})
# get token and project
token = createdUser["tokens"]["jwtAccessToken"]
self.header = {"Authorization": "Basic " + token}
self.project = createdUser["project"]
# create a component
component = {"name": self.fake.word()}
createdComponent = self.apiRequest(
self.apiUrl + "/component/" + self.project["_id"],
component,
self.header,
)
self.component = createdComponent
# create an applicationlog and set it as the global application Log.
appLog = {"name": self.fake.word()}
createdApplicationLog = self.apiRequest(
self.apiUrl
+ "/application-log/"
+ self.project["_id"]
+ "/"
+ createdComponent["_id"]
+ "/create",
appLog,
self.header,
)
self.applicationLog = createdApplicationLog
except requests.exceptions.HTTPError as error:
print("Couldnt create an application log to run a test, Error occured: ")
print(error)
def setUserObject(self):
self.user = {
"name": self.fake.name(),
"password": "******",
"confirmPassword": "******",
"email": self.fake.ascii_company_email(),
"companyName": self.fake.company(),
"jobRole": self.fake.job(),
"companySize": self.fake.random_int(),
"card": {"stripeToken": "tok_visa"},
"subscription": {"stripePlanId": 0},
"cardName": self.fake.credit_card_provider(),
"cardNumber": self.fake.credit_card_number(),
"cvv": self.fake.credit_card_security_code(),
"expiry": self.fake.credit_card_expire(),
"city": self.fake.city(),
"state": self.fake.country(),
"zipCode": self.fake.postcode(),
"companyRole": self.fake.job(),
"companyPhoneNumber": self.fake.phone_number(),
"planId": "plan_GoWIYiX2L8hwzx",
"reference": "Github",
}
return self
def apiRequest(self, url, body, headers):
response = requests.post(url, body, headers=headers)
return response.json()
def test_application_log_key_is_required(self):
logger = FyipeLogger(self.apiUrl, self.applicationLog["_id"], "")
response = logger.log("test content")
self.assertEqual(
"Application Log Key is required.",
response["message"],
"Application Log Key Required",
)
def test_content_is_required(self):
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.log("")
self.assertEqual(
"Content to be logged is required.", response["message"], "Content Required"
)
def test_valid_applicaiton_log_id_is_required(self):
logger = FyipeLogger(
self.apiUrl, "5eec6f33d7d57033b3a7d502", self.applicationLog["key"]
)
response = logger.log("content")
self.assertEqual(
"Application Log does not exist.",
response["message"],
"Valid Application Log",
)
def test_valid_string_content_of_type_info_is_logged(self):
log = "sample content to be logged"
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.log(log)
self.assertEqual(log, response["content"])
self.assertEqual("info", response["type"])
def test_valid_object_content_of_type_info_is_logged(self):
log = {"location": "Atlanta", "country": "USA"}
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.log(log)
self.assertEqual(log["location"], response["content"]["location"])
self.assertEqual(True, isinstance(response["content"], dict))
def test_valid_string_content_of_type_error_is_logged(self):
log = "sample content to be logged"
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.error(log)
self.assertEqual(log, response["content"])
self.assertEqual("error", response["type"])
def test_valid_object_content_of_type_warning_is_logged(self):
log = "sample content to be logged"
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.warning(log)
self.assertEqual(log, response["content"])
self.assertEqual("warning", response["type"])
def test_valid_object_content_of_type_info_with_one_tag_is_logged(self):
log = {"location": "Atlanta", "country": "USA"}
tag = "intent"
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.log(log, tag)
self.assertEqual(log["location"], response["content"]["location"])
self.assertEqual("info", response["type"])
self.assertIsInstance(response["tags"], list)
self.assertIn(tag, response["tags"])
def test_valid_object_content_of_type_error_with_no_tag_is_logged(self):
log = {"location": "Atlanta", "country": "USA"}
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.error(log)
self.assertEqual(log["location"], response["content"]["location"])
self.assertEqual("error", response["type"])
self.assertIsInstance(response["tags"], list)
self.assertEqual(0, len(response["tags"]))
def test_valid_object_content_of_type_warning_with_four_tags_is_logged(self):
log = {"location": "Atlanta", "country": "USA"}
tag = ["Enough", "python", "Error", "Serverside"]
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.warning(log, tag)
self.assertEqual(log["country"], response["content"]["country"])
self.assertEqual("warning", response["type"])
self.assertIsInstance(response["tags"], list)
self.assertEqual(len(tag), len(response["tags"]))
for item in tag:
self.assertIn(item, response["tags"])
def test_valid_object_content_of_type_warning_return_invalid_tags(self):
log = {"location": "Atlanta", "country": "USA"}
tag = 500
logger = FyipeLogger(
self.apiUrl, self.applicationLog["_id"], self.applicationLog["key"]
)
response = logger.warning(log, tag)
self.assertEqual("Invalid Content Tags to be logged", response, "Invalid Tags")
print("Address:\t ", fake.address())
print("Date this month:\t ", fake.date_this_month())
print("IPv6:\t ", fake.ipv6())
print("Postal code:\t ", fake.postalcode())
print("Seed:\t ", fake.seed())
print("AM/PM:\t ", fake.am_pm())
print("This year:\t ", fake.date_this_year())
print("ISBN10:\t ", fake.isbn10())
print("Postal code in state:\t ", fake.postalcode_in_state())
print("Instance:\t ", fake.seed_instance())
print("Android platform token:\t ", fake.android_platform_token())
print("Data time:\t ", fake.date_time())
print("ISBN3:\t ", fake.isbn13())
print("Postal code plus 4:\t ", fake.postalcode_plus4())
print("Sentence:\t ", fake.sentence())
print("Email:\t ", fake.ascii_company_email())
print("Date time add:\t ", fake.date_time_ad())
print("ISO8601:\t ", fake.iso8601())
print("Postcode:\t ", fake.postcode())
print("Sentence:\t ", fake.sentences())
print("ASCII email:\t ", fake.ascii_email())
print("Date time beween:\t ", fake.date_time_between())
print("ITIN:\t ", fake.itin())
print("Postcode in state:\t ", fake.postcode_in_state())
# print("Set formatter:\t ", fake.set_formatter())
print("ASCII free email:\t ", fake.ascii_free_email())
print("Date time between dates:\t ", fake.date_time_between_dates())
print("Fake job:\t ", fake.job())
print("Prefix:\t ", fake.prefix())
print("SHA1:\t ", fake.sha1())
print("ASCII safe email:\t ", fake.ascii_safe_email())
class Generator:
def __init__(self, locale='zh_CN'):
self.fake = Faker(locale)
"""一些生成器方法，生成姓名，手机号"""
def random_phone_number(self):
"""随机手机号"""
return self.fake.phone_number()
def random_name(self):
"""随机姓名"""
return self.fake.name()
def random_ssn(self):
"""随机身份证号"""
return self.fake.ssn()
def random_number(self, digits=18):
"""digits=18的随机数"""
return self.fake.random_number(digits, fix_len=True)
def random_address(self):
"""随机地址"""
return self.fake.address()
def random_post_code(self):
"""随机邮编"""
return self.fake.postcode()
def random_email(self):
"""随机邮箱地址"""
return self.fake.ascii_company_email()
def credit_card_number(self):
"""随机银行卡号"""
return self.fake.credit_card_number()
def random_company_name(self):
"""随机公司名称"""
return self.fake.company()
def random_ipv4(self):
"""随机IPV4地址"""
return self.fake.ipv4()
def random_str(self, min_chars=0, max_chars=8):
"""长度在最大值与最小值之间的随机字符串"""
return self.fake.pystr(min_chars=min_chars, max_chars=max_chars)
def factory_generate_ids(self, starting_id=1, increment=1):
""" 返回一个生成器函数，调用这个函数产生生成器，从starting_id开始，步长为increment。 """
def generate_started_ids():
val = starting_id
local_increment = increment
while True:
yield val
val += local_increment
return generate_started_ids
def factory_choice_generator(self, values):
""" 返回一个生成器函数，调用这个函数产生生成器，从给定的list中随机取一项。 """
def choice_generator():
my_list = list(values)
rand = random.Random()
while True:
yield rand.choice(my_list)
return choice_generator
#!/usr/bin/env python
from faker import Faker
import json
fake = Faker()
data = {}
for i in range(50):
data[i] = {}
data[i]['email'] = fake.ascii_company_email()
data[i]['address'] = fake.address()
data[i]['uri'] = fake.uri()
data[i]['latlng'] = fake.local_latlng(country_code='US')
# data_str = json.dump(data)
with open("db.json", "w") as outfile:
json.dump(data, outfile)
from faker import Faker
fake = Faker()
log = open('logs.csv', 'w')
log.write('data,ampm,bool,nome,telefone,email\n')
for _ in range(100):
log.write(','.join([
fake.date_time_this_decade().strftime('%m/%d/%Y'),
fake.am_pm(),
str(fake.pybool()),
fake.name(),
fake.bothify(text='??-#########', letters='123456789'),
fake.ascii_company_email()
]) + '\n')
