def test_pay_job(self):
self.client.login(request=HttpRequest(),
username=self.user.email,
password='******')
data = {'card_index': 0}
response = self.client.post(f'/jobs/{self.proposal.job.uuid}/pay.json',
data=data,
content_type='application/json')
self.assertEqual(response.status_code, 200, response.content)
self.assertEqual(response.get('Content-Type'), 'application/json',
response.content)
self.assertIn('uuid', response.json())
self.assertIn('transaction', response.json())
self.assertIn('id', response.json()['transaction'])
job: Job = Job.objects.get(uuid=str(self.proposal.job.uuid))
self.assertTrue(job.paid)
def test_create_feature_flag(self, mock_capture):
response = self.client.post(
f"/api/projects/{self.team.id}/feature_flags/",
{
"name": "Alpha feature",
"key": "alpha-feature",
"filters": {
"groups": [{
"rollout_percentage": 50
}]
}
},
format="json",
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
instance = FeatureFlag.objects.get(id=response.json()["id"])
self.assertEqual(instance.key, "alpha-feature")
# Assert analytics are sent
mock_capture.assert_called_once_with(
self.user.distinct_id,
"feature flag created",
{
"groups_count": 1,
"has_variants": False,
"variants_count": 0,
"has_rollout_percentage": True,
"has_filters": False,
"filter_count": 0,
"created_at": instance.created_at,
},
)
def get(self, request, format=None):
payload = urllib.parse.urlencode({"q" : self.request.GET.get('keywords', '')})
response = requests.get(self.autocomplete_url,params=payload)
ret = [
{"value": k, "label": k} for k in response.json()['sentences']
]
return Response(ret,status=status.HTTP_200_OK)
def validate_symbol(self, value):
"""
This method has three validations
1.-That symbol can-t be greater than 100 characteres
2.-The symbol is ok only is accepted in
companies registered on the New York Stock Exchange.
3.-If the symbol exists in our DB, you can't longer register again
"""
if not len(value) <= 10:
raise serializers.ValidationError(
"The Symbol can't be greater than 10 characters")
if Company.objects.filter(symbol=value).exists():
raise serializers.ValidationError(
"The Symbol are you already registered. Try another Symbol")
response = requests.get(
"https://finnhub.io/api/v1/search?q={}&token=c0qavjf48v6s0mp617v0".
format(value)
) # We consume Api to check if symbol exists in new york stock exchange
if not response.json()["count"]:
raise serializers.ValidationError(
"it's not exists this symbol in companies registered on the New York Stock Exchange."
)
return value
def test_list_cards(self):
client.login(username=self.user.email, password='******')
response = client.get('/profile/cards.json')
self.assertEqual(response.status_code, 200, response.content)
self.assertEqual(response.get('Content-Type'), 'application/json', response.content)
self.assertGreater(len(response.json()), 0)
def get_access_token(self, validated_data):
data = {
'grant_type': 'authorization_code',
'redirect_uri': validated_data['redirect_uri'],
'code': validated_data['code'],
'client_id': KEYCLOAK_CLIENT_ID,
'client_secret': KEYCLOAK_SECRET,
}
try:
response = requests.post(KEYCLOAK_TOKEN_URL, data=data)
except requests.exceptions.RequestException as e:
logger.warning(
'Unable to send authentication request. Error is %s', e)
raise KeycloakException('Unable to send authentication request.')
self.check_response(response)
try:
return response.json()['access_token']
except (ValueError, TypeError):
raise KeycloakException(
'Unable to parse JSON in authentication response.')
except KeyError:
raise KeycloakException(
'Authentication response does not contain token.')
def test_get_customer(self):
client.login(username=self.user.email, password='******')
self.user.create_customer()
response = client.get('/profile/customer.json')
self.assertEqual(response.get('Content-Type'), 'application/json', msg=response.content)
self.assertEqual(response.status_code, 200, msg=response.content)
self.assertIn('id', response.json())
def test_update_professional_profile(self):
client.login(username=self.professional.user.email, password='******')
data = {
'full_name': 'Grande Pequeno',
'email': '*****@*****.**',
'cpf': '567.933.940-45',
'address': {
'street': 'Lá mesmo',
'street_number': '40',
'zipcode': '36000-222',
'state': 'MG',
'city': 'Belo Origami',
'neighborhood': 'Centro',
'complementary': 'Casa',
},
'professional': {
'about': 'Hello World',
'occupation': self.professional.occupation,
'coren': self.professional.coren,
}
}
response = client.put(f'/profile.json', data=data, content_type='application/json')
json = response.json()
self.assertEqual(response.status_code, 200, msg=str(json))
self.assertIn('uuid', json)
self.assertEqual(json['uuid'], str(self.professional.user.uuid))
self.assertEqual(json['full_name'], data['full_name'])
self.assertEqual(json['professional']['about'], data['professional']['about'])
def test_one_transaction_in_range(self):
"""
Transaction in range returned correctly
"""
now = timezone.now().date()
Transaction.objects.create(title='trans1',
creation_date=now,
amount=32.5)
response = self.client.get(
reverse('transactions:transactions-by-range',
args=(
now - datetime.timedelta(days=1),
now + datetime.timedelta(days=1),
)))
esperado = [{
"id": 1,
"creation_date": str(now),
"confirmed": False,
"amount": 32.5,
"title": 'trans1',
"details": '',
"subtitle": 'generic'
}]
self.assertQuerysetEqual(
response.json(),
esperado,
)
def test_list_sent_proposals(self):
self.client.login(request=HttpRequest(),
username=self.user.email,
password='******')
response = self.client.get('/proposals/sent.json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0]['uuid'], str(self.proposal.uuid))
def test_two_transactions_in_range(self):
"""
Two transactions in range returned correctly
"""
now = timezone.now().date()
transactions = []
for i in range(2):
transactions.append(
Transaction.objects.create(title='trans%i' % i,
creation_date=now +
datetime.timedelta(days=i),
amount=300 + i))
response = self.client.get(
reverse('transactions:transactions-by-range',
args=(
now - datetime.timedelta(days=1),
now + datetime.timedelta(days=2),
)))
esperado = []
for item in transactions:
esperado.append({
'id': item.id,
'creation_date': str(item.creation_date),
'confirmed': item.confirmed,
'amount': item.amount,
'title': item.title,
'details': item.details,
'subtitle': item.subtitle
})
self.assertQuerysetEqual(
response.json(),
esperado[::-1],
)
def test_list_received_proposals(self):
self.client.logout()
self.client.login(request=HttpRequest(),
username=self.professional.user.email,
password='******')
response = self.client.get('/proposals/received.json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[0]['uuid'], str(self.proposal.uuid))
def get_omdb_api_body(title):
response = requests.get(
'http://www.omdbapi.com/?apikey={}&t={}'.format(
settings.OMDB_API_KEY, title))
if response.status_code == 200:
return response.json()
else:
raise ExternalAPIException()
def test_login(self):
client.logout()
self.professional.user.is_active = True
self.professional.user.save()
credentials = {
'email': self.professional.user.email,
'password': '******'
}
response = client.post('/auth/', data=credentials, content_type='application/json')
self.assertEqual(response.status_code, 200, msg=response.json())
self.assertIn('access', response.json())
token = response.json().get('access')
api_client = APIClient()
api_client.credentials(HTTP_AUTHORIZATION=f'Bearer {token}')
profile = api_client.get('/profile.json')
self.assertEqual(profile.status_code, 200, profile.json())
self.assertEqual(profile.json()['uuid'], str(self.professional.user.uuid))
def test_activate_user(self):
user = User.objects.create_user(
email='*****@*****.**',
password='******',
)
user.save()
data = {
'token': account_activation_token.make_token(user)
}
response = client.put(
f'/profile/{user.uuid}/activate.json',
data=data,
content_type='application/json'
)
self.assertEqual(response.status_code, 200, msg=response.content)
self.assertIn('is_active', response.json())
self.assertEqual(response.json()['is_active'], True)
def test_create_availability(self):
client.login(username=self.professional.user.email, password='******')
data = {
'start_datetime': (now() + timedelta(days=1)).isoformat(),
'end_datetime': (now() + timedelta(days=1, hours=3)).isoformat(),
}
response = client.post('/profile/availabilities.json', data=data, content_type='application/json')
json = response.json()
self.assertIn('uuid', json)
def get(self, request, uid, token, format=None):
payload = {'uid': uid, 'token': token}
url = "/api/users/activation/"
response = requests.post(url, data=payload)
if response.status_code == 204:
return Response({}, response.status_code)
else:
return Response(response.json())
def test_delete(self):
now = timezone.now().date()
trans = Transaction.objects.create(title='transac',
creation_date=now,
amount=300)
self.client.delete(
reverse('transactions:transaction-list-delete', args=(trans.id, )))
response = self.client.get(reverse('transactions:transaction-list'))
self.assertListEqual(response.json(), [])
def test_user_rating_your_own_article(self):
token = self.create_user(VALID_USER_DATA)
self.create_article(token=token, article=VALID_ARTICLE)
article = Articles.objects.all().first()
response = self.client.post(reverse('rate-article',
kwargs={'slug': article.slug}),
data={"ratings": 3.0},
HTTP_AUTHORIZATION=token)
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEquals(response.data, response.json())
def test_update_override(self):
# Create an override and, and make sure the my_flags response shows it
feature_flag_instance = FeatureFlag.objects.create(
team=self.team, created_by=self.user, key="beta-feature")
response = self.client.post(
"/api/projects/@current/feature_flag_overrides/my_overrides",
{
"feature_flag": feature_flag_instance.id,
"override_value": "hey-hey"
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
response = self.client.get(
f"/api/projects/{self.team.id}/feature_flags/my_flags")
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
first_flag = response_data[0]
self.assertEqual(first_flag["feature_flag"]["key"], "beta-feature")
self.assertEqual(first_flag["override"]["override_value"], "hey-hey")
# Update the override, and make sure the my_flags response reflects the update
response = self.client.post(
"/api/projects/@current/feature_flag_overrides/my_overrides",
{
"feature_flag": feature_flag_instance.id,
"override_value": "new-override"
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
response = self.client.get(
f"/api/projects/{self.team.id}/feature_flags/my_flags")
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
first_flag = response_data[0]
self.assertEqual(first_flag["feature_flag"]["key"], "beta-feature")
self.assertEqual(first_flag["override"]["override_value"],
"new-override")
# Ensure only 1 override exists in the DB for the feature_flag/user combo
self.assertEqual(
FeatureFlagOverride.objects.filter(
user=self.user, feature_flag=feature_flag_instance).count(), 1)
def test_list_self_availabilities(self):
availability = Availability.objects.create(
professional=self.professional,
start_datetime=(now() + timedelta(days=1)),
end_datetime=(now() + timedelta(days=1, hours=2)),
)
availability.save()
client.login(username=self.professional.user.email, password='******')
response = client.get('/profile/availabilities.json')
json = response.json()
self.assertEqual(json[0]['uuid'], str(availability.uuid))
def proxy_data(host, token, collection, what, version):
url = f"https://{host}/items/{collection}_v{version}"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}",
}
response = requests.post(url, data=json.dumps(what), headers=headers)
if response.status_code != 200:
raise Exception(
f"Directus collection error at {url}: {response.content}")
return response.json()
def test_cant_create_multivariate_feature_flag_with_variant_rollout_gt_100(
self):
response = self.client.post(
f"/api/projects/{self.team.id}/feature_flags/",
{
"name": "Multivariate feature",
"key": "multivariate-feature",
"filters": {
"groups": [{
"properties": [],
"rollout_percentage": None
}],
"multivariate": {
"variants": [
{
"key": "first-variant",
"name": "First Variant",
"rollout_percentage": 50
},
{
"key": "second-variant",
"name": "Second Variant",
"rollout_percentage": 25
},
{
"key": "third-variant",
"name": "Third Variant",
"rollout_percentage": 50
},
],
},
},
},
format="json",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.json().get("type"), "validation_error")
self.assertEqual(
response.json().get("detail"),
"Invalid variant definitions: Variant rollout percentages must sum to 100."
)
def test_create_multivariate_feature_flag(self, mock_capture):
response = self.client.post(
f"/api/projects/{self.team.id}/feature_flags/",
{
"name": "Multivariate feature",
"key": "multivariate-feature",
"filters": {
"groups": [{
"properties": [],
"rollout_percentage": None
}],
"multivariate": {
"variants": [
{
"key": "first-variant",
"name": "First Variant",
"rollout_percentage": 50
},
{
"key": "second-variant",
"name": "Second Variant",
"rollout_percentage": 25
},
{
"key": "third-variant",
"name": "Third Variant",
"rollout_percentage": 25
},
],
},
},
},
format="json",
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
instance = FeatureFlag.objects.get(id=response.json()["id"])
self.assertEqual(instance.key, "multivariate-feature")
# Assert analytics are sent
mock_capture.assert_called_once_with(
self.user.distinct_id,
"feature flag created",
{
"groups_count": 1,
"has_variants": True,
"variants_count": 3,
"has_filters": False,
"has_rollout_percentage": False,
"filter_count": 0,
"created_at": instance.created_at,
},
)
def test_update_profile(self):
client.login(username=self.user.email, password='******')
data = {
'full_name': 'Grande Pequeno',
'email': '*****@*****.**',
}
response = client.put(f'/profile.json', data=data, content_type='application/json')
json = response.json()
self.assertEqual(response.status_code, 200, msg=str(json))
self.assertIn('uuid', json)
self.assertEqual(json['uuid'], str(self.user.uuid))
self.assertEqual(json['full_name'], data['full_name'])
def __parseResponse(self, response):
"""
Parses the response returned by zeppelin APIs
"""
try:
responseJSON = response.json()
if responseJSON["status"] == "OK":
return responseJSON.get("body", True)
else:
return False
except Exception as ex:
return False
def get_directus_validator(host, token, collection, version):
url = f"https://{host}/items/validators_v{version}/{collection}"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}",
}
response = requests.get(url, headers=headers)
if response.status_code != 200:
# return an empty validator so we can capture the result.
return {}
result = response.json()
return result["data"]["validator"]
def test_create_profile(self):
client.logout()
data = {
'email': '*****@*****.**',
'full_name': 'Teste da Silva',
'password1': 'abda1234',
'password2': 'abda1234',
}
response = client.post('/profile.json', data=data)
json = response.json()
self.assertIn('uuid', json)
self.assertEqual(json['is_active'], False)
def test_create_override(self):
# Boolean override value
feature_flag_instance = FeatureFlag.objects.create(
team=self.team, created_by=self.user, key="beta-feature")
response = self.client.post(
"/api/projects/@current/feature_flag_overrides/my_overrides",
{
"feature_flag": feature_flag_instance.id,
"override_value": True
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIsNotNone(
FeatureFlagOverride.objects.get(team=self.team,
user=self.user,
feature_flag=feature_flag_instance,
override_value=True))
# String override value
feature_flag_instance_2 = FeatureFlag.objects.create(
team=self.team, created_by=self.user, key="beta-feature-2")
response = self.client.post(
"/api/projects/@current/feature_flag_overrides/my_overrides",
{
"feature_flag": feature_flag_instance_2.id,
"override_value": "hey-hey"
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertIsNotNone(
FeatureFlagOverride.objects.get(
team=self.team,
user=self.user,
feature_flag=feature_flag_instance_2,
override_value="hey-hey"))
response = self.client.get(
f"/api/projects/{self.team.id}/feature_flags/my_flags")
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
first_flag = response_data[0]
self.assertEqual(first_flag["feature_flag"]["key"], "beta-feature-2")
self.assertEqual(first_flag["override"]["override_value"], "hey-hey")
second_flag = response_data[1]
self.assertEqual(second_flag["feature_flag"]["key"], "beta-feature")
self.assertEqual(second_flag["override"]["override_value"], True)
third_flag = response_data[2]
self.assertEqual(third_flag["feature_flag"]["key"], "red_button")
self.assertEqual(third_flag["override"], None)
def test_create_card(self):
client.login(username=self.user.email, password='******')
self.user.create_customer()
data = {
"card_expiration_date": "1122",
"card_number": "4018720572598048",
"card_cvv": "123",
"card_holder_name": "Cersei Lannister"
}
response = client.post('/profile/cards.json', data=data, content_type='application/json')
self.assertEqual(response.status_code, 200, msg=response.content)
self.assertEqual(response.get('Content-Type'), 'application/json', response.content)
self.assertIn('id', response.json())
