def test_reject_friendship_request_successfully():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 2):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		status_code = insert_new_friendship_request(data[1]['email'], data[0]['email'], collection)
		assert status_code == HTTP_CREATED
		user = collection.find_one({'email': data[0]['email']})
		assert len(user['requests']) == 1

		result, status_code = respond_to_friendship_request(data[0]['email'],
															data[1]['email'],
															collection,
															accept=False)

		assert status_code == HTTP_OK
		assert result == {'Reject_friendship_request':
				'Solicitud de amistad rechazada con éxito'}

		client.close()
def test_get_user_friends():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 4):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': '{0}'.format(i)})
			insert_new_user(data[i], collection)

		result = collection.find({})
		assert len(list(result)) == 4

		my_user = data[3]
		for i in range(0, 3):
			insert_new_friendship_request(data[i]['email'], my_user['email'], collection)
		for i in range(0, 3):
			_, status_code = respond_to_friendship_request(my_user['email'],
														   data[i]['email'],
														   collection,
														   accept=True)
			assert status_code == 200

		result = get_user_friends_from_db(my_user['email'], collection)
		assert len(result) == 3

		list_result = list(result)
		for i in range(0, 3):
			assert data[i]['email'] == list_result[i]['email']

		assert my_user not in result
		client.close()
Beispiel #3
0
def test_comment_video_fails_video_does_not_exist():
    client = MongoClient()
    collection = client[DB]['videos']

    video_data = {
        'title': 'test',
        'url': 'test.com',
        'user': '******',
        'isPrivate': True,
        'comments': []
    }

    _id = '5edbc9196ab5430010391c79'
    insert_video_into_db(_id, video_data, collection)

    user = '******'
    text = 'Este es un comentario de prueba'
    __inexistent_id = '5edbc9196ab5430010391c78'
    status_code = insert_comment_into_video(__inexistent_id, user, text,
                                            collection)
    assert status_code == HTTP_INTERNAL_SERVER_ERROR

    this_video = collection.find_one({'_id': ObjectId(_id)})

    assert len(this_video['comments']) == 0
    client.close()
def test_new_collection_is_empty():
	client = MongoClient()
	coll = client[DB]['users']

	result = list(coll.find({}))
	client.close()
	assert len(result) == 0
Beispiel #5
0
def test_second_comment_video_comes_first():
    client = MongoClient()
    collection = client[DB]['videos']

    video_data = {
        'title': 'test',
        'url': 'test.com',
        'user': '******',
        'isPrivate': True,
        'comments': []
    }

    _id = '5edbc9196ab5430010391c79'
    insert_video_into_db(_id, video_data, collection)

    user = '******'
    text_01 = 'Este es un comentario de prueba'
    insert_comment_into_video(_id, user, text_01, collection)
    text_02 = 'Este es el segundo comentario'
    status_code = insert_comment_into_video(_id, user, text_02, collection)
    assert status_code == HTTP_CREATED

    this_video = collection.find_one({'_id': ObjectId(_id)})

    assert len(this_video['comments']) == 2
    comment = this_video['comments'][0]

    assert comment['text'] == text_02
    assert comment['user'] == user
    assert 'timestamp' in comment.keys()
    client.close()
Beispiel #6
0
def test_ten_comments_in_order():
    client = MongoClient()
    collection = client[DB]['videos']

    video_data = {
        'title': 'test',
        'url': 'test.com',
        'user': '******',
        'isPrivate': True,
        'comments': []
    }

    _id = '5edbc9196ab5430010391c79'
    insert_video_into_db(_id, video_data, collection)

    user = '******'
    text = 'Este es el comentario numero {0}'
    for i in range(0, 10):
        text = text.format(i)
        insert_comment_into_video(_id, user, text, collection)

    this_video = collection.find_one({'_id': ObjectId(_id)})

    assert len(this_video['comments']) == 10

    for i in range(10, 0):
        comment = this_video['comments'][i]
        assert comment['text'] == text.format(i)

    client.close()
Beispiel #7
0
def test_insert_ten_videos():
    client = MongoClient()
    collection = client[DB]['videos']
    for i in range(0, 10):
        data = {
            'title': 'test_{0}'.format(i),
            'url': 'test.com',
            'user': '******',
            'isPrivate': False
        }

        # Esto se hace porque sino el id es repetido y tira conflicto.
        _id = '5edbc9196ab5430010391c7' + str(i)
        insert_video_into_db(_id, data, collection)

    fifth_video = collection.find_one({'title': 'test_5'})
    assert fifth_video is not None
    assert not fifth_video['is_private']
    eleventh_video = collection.find_one({'title': 'test_11'})
    assert eleventh_video is None

    result = list(collection.find({}))
    client.close()

    assert len(result) == 10
    for counter, document in enumerate(result):
        assert document['title'] == 'test_{0}'.format(counter)
def test_delete_friendship_relationship_fails_when_friendship_does_not_exist():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 3):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': '{0}'.format(i)})
			insert_new_user(data[i], collection)

		for i in range(0, 1):
			insert_new_friendship_request(data[i]['email'], data[2]['email'], collection)
			respond_to_friendship_request(data[2]['email'], data[i]['email'],
										  collection, accept=True)

		user = collection.find_one({'email': data[2]['email']})
		assert len(user['friends']) == 1

		status_code = delete_friendship_relationship(data[2]['email'],
													 data[1]['email'],
													 collection)
		assert status_code == HTTP_FORBIDDEN

		user = collection.find_one({'email': data[2]['email']})
		assert len(user['friends']) == 1
		client.close()
def test_delete_friendship_relationship_fails_when_user_is_not_found():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 3):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': '{0}'.format(i)})
			insert_new_user(data[i], collection)

		for i in range(0, 1):
			insert_new_friendship_request(data[i]['email'], data[2]['email'], collection)
			respond_to_friendship_request(data[2]['email'], data[i]['email'],
										  collection, accept=True)

		user = collection.find_one({'email': data[2]['email']})
		assert len(user['friends']) == 1

		status_code = delete_friendship_relationship(data[2]['email'],
													 data[0]['email'],
													 collection)
		assert status_code == HTTP_OK

		third_user = '******'	# Not existing
		status_code = delete_friendship_relationship(data[2]['email'],
													 third_user,
													 collection)
		assert status_code == HTTP_NOT_FOUND

		user = collection.find_one({'email': data[2]['email']})
		assert len(user['friends']) == 0

		client.close()
def test_reject_friendship_non_existing_user_fails():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 2):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		status_code = insert_new_friendship_request(data[1]['email'], data[0]['email'], collection)
		assert status_code == HTTP_CREATED
		user = collection.find_one({'email': data[0]['email']})
		assert len(user['requests']) == 1

		respond_to_friendship_request(data[0]['email'],
									  data[1]['email'],
									  collection,
									  accept=True)

		third_user = '******'	# Not existing
		result, status_code = respond_to_friendship_request(data[0]['email'],
															third_user,
															collection,
															accept=False)
		assert status_code == HTTP_NOT_FOUND
		assert result == {'Reject_friendship_request':
						  'La solicitud no se pudo completar porque uno de los usuarios no existe'}

		client.close()
def test_reject_friendship_non_existing_fails():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 2):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		status_code = insert_new_friendship_request(data[1]['email'], data[0]['email'], collection)
		assert status_code == HTTP_CREATED
		user = collection.find_one({'email': data[0]['email']})
		assert len(user['requests']) == 1

		# La request la tiene que aceptar el usuario 0, no el 1
		result, status_code = respond_to_friendship_request(data[1]['email'],
															data[0]['email'],
															collection,
															accept=False)

		assert status_code == HTTP_FORBIDDEN
		assert result == {'Reject_friendship_request':
			'La solicitud de amistad que queres responder no existe'}

		client.close()
def test_delete_inexistent_dislike_fails():
	client = MongoClient()
	collection = client[DB]['videos']

	_id = '5df1679ee0acd518e5cfd002'
	status_code = insert_video_into_db(_id, empty_video_01, collection)
	assert status_code == HTTP_CREATED

	fake_user = {'email': '*****@*****.**'}
	status_code = delete_like_video(_id, fake_user, collection)
	assert status_code == HTTP_CONFLICT
	client.close()
def test_insert_complete_user_successfully():
	client = MongoClient()
	collection = client[DB]['users']

	data = {'email': '*****@*****.**', 'full name': '', 'friends': [], 'requests': []}
	insert_new_user(data, collection)

	result = list(collection.find({}))
	first_user = result[0]
	client.close()

	assert len(result) == 1
	assert first_user['email'] == '*****@*****.**'
def test_insert_new_user():
	client = MongoClient()
	collection = client[DB]['users']

	data = {'email': '*****@*****.**', 'full name': ''}
	insert_new_user(data, collection)

	result = list(collection.find({}))
	first_user = result[0]
	client.close()

	assert len(result) == 1
	assert first_user['email'] == '*****@*****.**'
def test_video_not_found_fails():
	client = MongoClient()
	collection = client[DB]['videos']

	status_code = insert_video_into_db('5df1679ee0acd518e5cfd002', empty_video_01, collection)
	assert status_code == HTTP_CREATED

	result = list(collection.find({}))
	assert len(result) == 1

	fake_user = {'email': '*****@*****.**'}
	status_code = like_video('22222225ef1679ee0acd518e', fake_user, collection)
	assert status_code == HTTP_NOT_FOUND
	client.close()
def test_insert_new_friendship_request_fails_my_id_is_invalid():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 2):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		third_user = '******'	# Not existing
		status_code = insert_new_friendship_request(third_user, data[0]['email'], collection)
		assert status_code == HTTP_NOT_FOUND

		client.close()
def test_like_is_successful():
	client = MongoClient()
	collection = client[DB]['videos']

	_id = '5df1679ee0acd518e5cfd002'
	status_code = insert_video_into_db(_id, empty_video_01, collection)
	assert status_code == HTTP_CREATED

	fake_user = {'email': '*****@*****.**'}
	status_code = like_video(_id, fake_user, collection)
	assert status_code == HTTP_CREATED

	video = collection.find_one({'_id': ObjectId(_id)})
	assert fake_user['email'] in video['likes']
	client.close()
    def set_up_db(self):
        """
        Setup In memory MongoDB database
        """
        self.client = MongoClient()
        db = self.client['bankaccountservice']

        collection = db['bank_account']
        bank_account_data = [{
            'user_id': '105398890',
            'account_number': '000100',
            'balance': 100000,
            'create_date': '2021-04-06 01:37:14.422Z'
        }, {
            'user_id': '105398891',
            'account_number': '000101',
            'balance': 60000,
            'create_date': '2021-04-06 01:37:14.422Z'
        }]
        for bank_account in bank_account_data:
            collection.insert_one(bank_account)

        collection = db['transaction']
        transaction_data = [{
            'account_number': '000100',
            'currency': 'COP',
            'type': 'DEPOSIT',
            'previous_balance': 0,
            'amount': 200000,
            'trm': 0,
            'create_date': '2021-05-06 01:37:14.422Z'
        }, {
            'account_number': '000100',
            'currency': 'COP',
            'type': 'WITHDRAWAL',
            'previous_balance': 200000,
            'amount': 100000,
            'trm': 0,
            'create_date': '2021-05-06 01:47:14.422Z'
        }, {
            'account_number': '000101',
            'currency': 'COP',
            'type': 'DEPOSIT',
            'previous_balance': 0,
            'amount': 100000,
            'trm': 0,
            'create_date': '2021-05-06 01:17:14.422Z'
        }, {
            'account_number': '000101',
            'currency': 'COP',
            'type': 'WITHDRAWAL',
            'previous_balance': 100000,
            'amount': 40000,
            'trm': 0,
            'create_date': '2021-05-06 01:27:14.422Z'
        }]
        for transaction in transaction_data:
            collection.insert_one(transaction)

        return db
def test_get_users_when_filter_is_empty_gets_all_except_me():
	client = MongoClient()
	collection = client[DB]['users']
	data = []
	for i in range(0, 5):
		data.append({'email': 'test_{0}@test.com'.format(i),
					 'full name': '{0}'.format(i)})
		insert_new_user(data[i], collection)

	_all = get_users_by_query('', '*****@*****.**', collection)
	assert len(list(_all)) == 4

	emails = [item['email'] for item in list(_all)]
	assert '*****@*****.**' not in emails

	client.close()
Beispiel #20
0
    def set_up_db(self):
        """
        Setup In memory MongoDB database
        """
        self.client = MongoClient()
        db = self.client['userservice']

        collection = db['user']
        user_data = [{
            'user_id': '105398890',
            'pin': 2091,
            'user_name': 'playvox',
            'password': '******',
            'create_date': '2021-03-06 01:37:14.422Z'
        }, {
            'user_id': '105398891',
            'pin': 2090,
            'user_name': 'docker',
            'password': '******',
            'create_date': '2021-03-06 01:57:14.422Z'
        }]
        for user in user_data:
            collection.insert_one(user)

        return db
Beispiel #21
0
def test_get_user_token_fails():
    client = MongoClient()
    collection = client[DB]['users']

    data = {'email': '@test.com', 'full name': ''}
    insert_new_user(data, collection)

    result = list(collection.find({}))
    first_user = result[0]

    user_token = get_user_token('@test.com', collection)
    client.close()

    assert len(result) == 1
    assert first_user['email'] == '@test.com'
    assert user_token == ''
def test_get_user_friends_fails():
	client = MongoClient()
	collection = client[DB]['users']
	data = []
	for i in range(0, 4):
		data.append({'email': 'test_{0}@test.com'.format(i),
					 'full name': '{0}'.format(i)})
		insert_new_user(data[i], collection)

	result = collection.find({})
	assert len(list(result)) == 4

	third_user = '******'	# Not existing
	result = get_user_friends_from_db(third_user, collection)
	assert result == 404
	client.close()
class TestAbstractFetcher(unittest.TestCase):
    def setUp(self) -> None:
        self.client = MongoClient()
        self.db = PriceDatabase(collection_name="UnitTests",
                                client=self.client)
        self.fetcher = MockedFetcher(self.db)

    def tearDown(self) -> None:
        self.client.close()

    def test_no_data_case(self):
        self.assertRaises(Exception,
                          self.fetcher._format_cheapest_product_tweet,
                          "2080 TI")

    @staticmethod
    def create_basic_post():
        return {
            "product_name": "Cheapest 2080 TI",
            "product_brand": "ASUS",
            "product_type": "2080 TI",
            "product_price": 900.0,
            "source": "Vendor",
            "url": "http://www.vendor.com"
        }

    def test_only_yesterday_post_case(self):
        yesterday_post = self.create_basic_post()
        yesterday_post["timestamp"] = get_yesterday_datetime()
        self.db.collection.insert_one(yesterday_post)
        self.assertRaises(Exception,
                          self.fetcher._format_cheapest_product_tweet,
                          "2080 TI")

    def test_only_today_post_case(self):
        today_post = self.create_basic_post()
        today_post["timestamp"] = get_today_datetime()
        self.db.collection.insert_one(today_post)
        self.fetcher._format_cheapest_product_tweet("2080 TI")

    def test_yesterday_and_today_post_case(self):
        posts = [self.create_basic_post(), self.create_basic_post()]
        posts[0]["timestamp"] = get_yesterday_datetime()
        posts[1]["timestamp"] = get_today_datetime()
        posts[1]["product_price"] = posts[0]["product_price"] * 2
        self.db.collection.insert_many(posts)
        self.fetcher._format_cheapest_product_tweet("2080 TI")
Beispiel #24
0
def test_filter_videos_for_specific_user_successfuly_all_own_videos():
    client = MongoClient()
    collection = client[DB]['videos']
    users_collection = client[DB]['users']

    user_filtering = '*****@*****.**'

    data = {
        'title': 'test',
        'url': 'test.com',
        'user': user_filtering,
        'isPrivate': True
    }

    data2 = {
        'title': 'test2',
        'url': 'test2.com',
        'user': user_filtering,
        'isPrivate': True
    }

    _id1 = '5edbc9196ab5430010391c79'
    _id2 = '5edbc9196ab5430010391c78'

    insert_video_into_db(_id1, data, collection)
    insert_video_into_db(_id2, data2, collection)

    data['_id'] = _id1
    data2['_id'] = _id2

    result = list(collection.find({}))

    assert len(result) == 2

    user = {'email': user_filtering, 'full name': 'Prueba'}
    insert_new_user(user, users_collection)

    filtered_videos = filter_videos_for_specific_user([data, data2],
                                                      user_filtering,
                                                      users_collection,
                                                      collection)
    assert len(filtered_videos) == 2
    assert filtered_videos[0] == data
    assert filtered_videos[1] == data2

    client.close()
def test_get_user_requests_fails():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 4):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': '{0}'.format(i)})
			insert_new_user(data[i], collection)

		result = collection.find({})
		assert len(list(result)) == 4

		third_user = '******'	# Not existing
		result = get_user_requests_from_db(third_user, collection)
		assert result == HTTP_NOT_FOUND
		client.close()
def test_get_user_by_email_successfully():
	client = MongoClient()
	collection = client[DB]['users']

	email = '*****@*****.**'
	data = {'email': email, 'full name': ''}
	insert_new_user(data, collection)

	result = list(collection.find({}))
	first_user = result[0]

	assert len(result) == 1
	assert first_user['email'] == '*****@*****.**'

	result_get = get_user_by_email(email, collection)
	result = list(collection.find({}))
	assert result_get['email'] == email
	client.close()
Beispiel #27
0
def test_add_notification_token():
    client = MongoClient()
    collection = client[DB]['users']

    data = {'email': '@test.com', 'full name': ''}
    insert_new_user(data, collection)

    status_code = add_notifications_token('@test.com', 'FAKE_TOKEN',
                                          collection)

    result = list(collection.find({}))
    first_user = result[0]
    client.close()

    assert len(result) == 1
    assert first_user['email'] == '@test.com'
    assert first_user['notifications_token'] == 'FAKE_TOKEN'
    assert status_code == HTTP_CREATED
def test_insert_new_friendship_request_success():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 2):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		# First user requests second user to be his/her friend
		status_code = insert_new_friendship_request(data[0]['email'],
													data[1]['email'],
													collection)
		assert status_code == HTTP_CREATED
		assert _mock.called

		client.close()
def test_insert_new_friendship_request_two_users():
	with patch('app_server.relationships_functions.send_notification_to_user') as _mock:
		client = MongoClient()
		collection = client[DB]['users']
		data = []
		for i in range(0, 3):
			data.append({'email': 'test_{0}@test.com'.format(i),
						 'full name': ''})
			insert_new_user(data[i], collection)

		for i in range(1, 3):
			status_code = insert_new_friendship_request(data[i]['email'], data[0]['email'], collection)
			assert status_code == HTTP_CREATED

		requests = collection.find_one({'email': data[0]['email']})['requests']
		assert len(requests) == 2

		client.close()
def test_get_user_that_doesnt_exist():
	client = MongoClient()
	collection = client[DB]['users']

	email = '*****@*****.**'
	data = {'email': email, 'full name': ''}
	insert_new_user(data, collection)

	result = list(collection.find({}))
	first_user = result[0]

	assert len(result) == 1
	assert first_user['email'] == '*****@*****.**'

	result_get = get_user_by_email('*****@*****.**', collection)
	result = list(collection.find({}))
	assert result_get is None
	client.close()