# import faker, logging, pytest
# from slugify import slugify

# from django.contrib.auth import get_user_model
# from django.core.management import call_command

# from .fixtures import *
# from ..models import *
# from investment.tests.fixtures import random_currency

# pytestmark = pytest.mark.django_db
# fake = faker.Faker()
# logger = logging.getLogger()

# class TestTagModel:
#     def test_init(self):
#         tag = Tag.objects.create(text='Some Tag Title')
#         assert tag.pk is not None

#     def test_str(self, random_tag):
#         assert str(random_tag) == random_tag.text


# class TestEntryStatusModel:
#     def test_init(self):
#         entry_status = EntryStatus.objects.create(title='Some Entry Status')
#         assert entry_status.pk is not None

#     def test_str(self, random_entry_status):
#         assert str(random_entry_status) == random_entry_status.title


# class TestPersonPrefixModel:
#     def test_init(self):
#         person_prefix = PersonPrefix.objects.create(title='SomePrefix')
#         assert person_prefix.pk is not None

#     def test_str(self, random_person_prefix):
#         assert str(random_person_prefix) == random_person_prefix.title


# class TestPersonModel:
#     def test_init(self):
#         person = Person.objects.create(first_name='Some First name', last_name='Some Last Name')
#         assert person.pk is not None

#     def test_str(self, random_person):
#         string_represenation = '%s %s %s' % (random_person.first_name, random_person.last_name, ('(%s)' % random_person.employer) if random_person.employer else '')
#         assert str(random_person) == string_represenation

#     def test_entry_str(self, random_person):
#         assert str(Entry.objects.get(id=random_person.id)) == str(random_person)

#     def test_is_employee(self, random_employee, random_person):
#         assert random_employee.is_employee
#         assert not random_person.is_employee


# class TestCompanyTypeModel:
#     def test_init(self):
#         company_type = CompanyType.objects.create(title='Some Company Type')
#         assert company_type.pk is not None

#     def test_str(self, random_company_type):
#         assert str(random_company_type) == random_company_type.title


# class TestCompanyModel:
#     def test_init(self):
#         company = Company.objects.create(title='Some Company Title')
#         assert company.pk is not None

#     def test_str(self, random_company):
#         assert str(random_company) == random_company.title

#     def test_entry_str(self, random_company):
#         assert str(Entry.objects.get(id=random_company.id)) == str(random_company)


# class TestContactLocationModel:
#     def test_init(self):
#         contact_location = ContactLocation.objects.create(location='Some Location')
#         assert contact_location.pk is not None

#     def test_str(self, random_contact_location):
#         assert str(random_contact_location) == random_contact_location.location


# class TestContactTelephoneTypeModel:
#     def test_init(self):
#         telephone_type = ContactTelephoneType.objects.create(telephone_type='Some telephone type')
#         assert telephone_type.pk is not None

#     def test_str(self, random_contact_telephone_type):
#         assert str(random_contact_telephone_type) == random_contact_telephone_type.telephone_type


# class TestContactCountryModel:
#     def test_init(self):
#         contact_country = ContactCountry.objects.create(country_name='Some Country Name', country_code='SCN')
#         assert contact_country.pk is not None

#     def test_str(self, random_contact_country):
#         assert str(random_contact_country) == random_contact_country.country_name


# class TestBankingContactModel:
#     def test_init(self, random_contact_location, random_person, random_currency):
#         banking_contact = BankingContact.objects.create(
#             location=random_contact_location,
#             entry=random_person.get_casted_entry(),
#             institute='Some Institute',
#             iban='DE12345678910',
#             currency=random_currency,
#         )
#         assert banking_contact.pk is not None

#     def test_str(self, random_banking_contact):
#         assert str(random_banking_contact) == f'{random_banking_contact.institute}, {random_banking_contact.iban}'


# class TestAddressContactModel:
#     def test_init(self, random_contact_location, random_person, random_contact_country):
#         address_contact = AddressContact.objects.create(
#             location=random_contact_location,
#             entry=random_person.get_casted_entry(),
#             street='Some Street',
#             city='Some City',
#             country=random_contact_country
#         )
#         assert address_contact.pk is not None

#     def test_str(self, random_address_contact):
#         assert str(random_address_contact) == f'{random_address_contact.street}, {random_address_contact.zip} {random_address_contact.city}, {random_address_contact.country}'


# class TestTelephoneContactModel:
#     def test_init(self, random_contact_location, random_person, random_contact_telephone_type):
#         telephone_contact = TelephoneContact.objects.create(
#             location=random_contact_location,
#             entry=random_person.get_casted_entry(),
#             number='Some Street',
#             telephone_type=random_contact_telephone_type
#         )
#         assert telephone_contact.pk is not None

#     def test_str(self, random_telephone_contact):
#         assert str(random_telephone_contact) == f'{random_telephone_contact.number}'


# class TestEmailContactModel:
#     def test_init(self, random_contact_location, random_person):
#         email_contact = EmailContact.objects.create(
#             location=random_contact_location,
#             entry=random_person.get_casted_entry(),
#             address='some@email.com'
#         )
#         assert email_contact.pk is not None

#     def test_str(self, random_email_contact):
#         assert str(random_email_contact) == f'{random_email_contact.address}'


# class TestWebsiteContactModel:
#     def test_init(self, random_contact_location, random_person):
#         website_contact = WebsiteContact.objects.create(
#             location=random_contact_location,
#             entry=random_person.get_casted_entry(),
#             url='some.url'
#         )
#         assert website_contact.pk is not None

#     def test_str(self, random_website_contact):
#         assert str(random_website_contact) == f'{random_website_contact.url}'


# class TestPrimaryContact:

#     def test_primary_contacts(self, random_person):
#         entry = random_person.get_casted_entry()

#         assert random_person.primary_banking_contact() is None
#         assert random_person.primary_address_contact() is None
#         assert random_person.primary_telephone_contact() is None
#         assert random_person.primary_email_contact() is None
#         assert random_person.primary_website_contact() is None

#         banking_contact = random_banking_contact(True, entry)
#         address_contact = random_address_contact(True, entry)
#         telephone_contact = random_telephone_contact(True, entry)
#         email_contact = random_email_contact(True, entry)
#         website_contact = random_website_contact(True, entry)

#         random_person.refresh_from_db()

#         assert random_person.primary_banking_contact() == banking_contact
#         assert random_person.primary_address_contact() == address_contact
#         assert random_person.primary_telephone_contact() == telephone_contact
#         assert random_person.primary_email_contact() == email_contact
#         assert random_person.primary_website_contact() == website_contact

#     def test_switch_primary(self, random_person):
#         primary_contact = random_email_contact(True, random_person.get_casted_entry())
#         non_primary_contact = random_email_contact(False, random_person.get_casted_entry())

#         assert primary_contact.primary is True
#         assert non_primary_contact.primary is False

#         non_primary_contact.primary = True
#         non_primary_contact.save()

#         primary_contact.refresh_from_db()

#         assert primary_contact.primary is False
#         assert non_primary_contact.primary is True


# class TestDynamicCharField:
#     def test_init(self):
#         dynamic_char_field = DynamicCharField.objects.create(
#             title='Some Dynamic Char Field'
#         )
#         assert dynamic_char_field.pk is not None

#     def test_str(self, random_dynamic_char_field):
#         assert str(random_dynamic_char_field) == random_dynamic_char_field.key

#     def test_get_field_type(self, random_dynamic_char_field):
#         assert random_dynamic_char_field.get_field_type() == 'CharField'

#     def test_validate_field(self, random_dynamic_char_field):
#         assert random_dynamic_char_field.validate_field('Some String')

#     def test_empty_dict(self, random_dynamic_char_field):
#         empty_dict = {
#             'title': random_dynamic_char_field.title,
#             'field_type': random_dynamic_char_field.get_field_type(),
#             'content': '',
#             'class_name': random_dynamic_char_field.__class__.__name__
#         }
#         assert random_dynamic_char_field.get_empty_dict() == empty_dict


# class TestDynamicRangeField:
#     def test_init(self):
#         dynamic_range_field = DynamicRangeField.objects.create(
#             title='Some Dynamic Char Field',
#             range_min=0,
#             range_max=100,
#         )
#         assert dynamic_range_field.pk is not None

#     def test_str(self, random_dynamic_range_field):
#         assert str(random_dynamic_range_field) == random_dynamic_range_field.key

#     def test_get_field_type(self, random_dynamic_range_field):
#         assert random_dynamic_range_field.get_field_type() == 'RangeField'

#     def test_validate_field(self, random_dynamic_range_field):
#         assert random_dynamic_range_field.validate_field(0)[0]
#         assert random_dynamic_range_field.validate_field(100)[0]
#         assert not random_dynamic_range_field.validate_field(101)[0]
#         assert not random_dynamic_range_field.validate_field(-1)[0]
#         assert random_dynamic_range_field.validate_field('50')[0]
#         assert not random_dynamic_range_field.validate_field('abc')[0]

#     def test_empty_dict(self, random_dynamic_range_field):
#         empty_dict = {
#             'range_min': random_dynamic_range_field.range_min,
#             'range_max': random_dynamic_range_field.range_max,
#             'title': random_dynamic_range_field.title,
#             'field_type': random_dynamic_range_field.get_field_type(),
#             'content': '',
#             'class_name': random_dynamic_range_field.__class__.__name__
#         }
#         assert random_dynamic_range_field.get_empty_dict() == empty_dict


# class TestDynamicChoiceField:
#     def test_init(self):
#         dynamic_choice_field = DynamicChoiceField.objects.create(
#             title='Some Dynamic Char Field',
#             choices=['a', 'b', 'c']
#         )
#         assert dynamic_choice_field.pk is not None

#     def test_str(self, random_dynamic_choice_field):
#         assert str(random_dynamic_choice_field) == random_dynamic_choice_field.key

#     def test_get_field_type(self, random_dynamic_choice_field):
#         assert random_dynamic_choice_field.get_field_type() == 'ChoiceField'

#     def test_validate_field(self, random_dynamic_choice_field):
#         choices = random_dynamic_choice_field.choices
#         for choice in choices:
#             assert random_dynamic_choice_field.validate_field(choice)[0]
#         assert not random_dynamic_choice_field.validate_field(choices[0]+'anotherstring')[0]

#     def test_empty_dict(self, random_dynamic_choice_field):
#         empty_dict = {
#             'choices': random_dynamic_choice_field.choices,
#             'title': random_dynamic_choice_field.title,
#             'field_type': random_dynamic_choice_field.get_field_type(),
#             'content': '',
#             'class_name': random_dynamic_choice_field.__class__.__name__
#         }
#         assert random_dynamic_choice_field.get_empty_dict() == empty_dict


# class TestDynamicField:
#     def test_add_field(self, random_person, random_company):
#         assert random_person.additional_fields == {}
#         assert random_company.additional_fields == {}

#         field = random_dynamic_char_field()

#         random_person.refresh_from_db()
#         random_company.refresh_from_db()

#         assert random_person.additional_fields == {field.get_key(): field.get_empty_dict()}
#         assert random_company.additional_fields == {field.get_key(): field.get_empty_dict()}

#     def test_change_field(self, random_person, random_company):
#         field = random_dynamic_char_field()
#         field.title = field.title + 'a'
#         field.save()
#         random_person.refresh_from_db()
#         random_company.refresh_from_db()
#         assert random_person.additional_fields == {field.get_key(): field.get_empty_dict()}
#         assert random_company.additional_fields == {field.get_key(): field.get_empty_dict()}

#     def test_remove_field(self, random_person, random_company):
#         field = random_dynamic_char_field()
#         random_person.refresh_from_db()
#         random_company.refresh_from_db()
#         assert random_person.additional_fields == {field.get_key(): field.get_empty_dict()}
#         assert random_company.additional_fields == {field.get_key(): field.get_empty_dict()}
#         field.delete()
#         random_person.refresh_from_db()
#         random_company.refresh_from_db()
#         assert random_person.additional_fields == {}
#         assert random_company.additional_fields == {}

#     def add_entries_with_initializing_additional_fields(self, random_dynamic_char_field, random_dynamic_choice_field, random_dynamic_range_field):
#         person = random_person()
#         company = random_company()
#         assert person.additional_fields != {}
#         assert company.additional_fields != {}


# class TestActivityTypeModel:
#     def test_init(self):
#         activity_type = ActivityType.objects.create(title='Some Activity Type')
#         assert activity_type.pk is not None

#     def test_str(self, random_activity_type):
#         assert str(random_activity_type) == random_activity_type.title


# class TestActivityModel:
#     def test_init(self):
#         activity = Activity.objects.create(title='Some Activity')
#         assert activity.pk is not None

#     def test_str(self, random_activity):
#         assert str(random_activity) == random_activity.title


# class TestEntryInChargeRequestModel:
#     def test_init(self):
#         entry = random_person().get_casted_entry()
#         employee = random_employee()

#         entry_in_charge_request = EntryInChargeRequest.objects.create(
#             entry=entry,
#             in_charge=employee
#         )
#         assert entry_in_charge_request.pk is not None

#     def test_approve_add(self, random_entry_in_charge_add_request):
#         assert random_entry_in_charge_add_request.entry.in_charge.all().count() == 0
#         random_entry_in_charge_add_request.status = EntryInChargeRequestStatus.APPROVED.value
#         random_entry_in_charge_add_request.save()

#         assert random_entry_in_charge_add_request.entry.in_charge.all().count() == 1

#     def test_approve_remove(self, random_entry_in_charge_remove_request):
#         assert random_entry_in_charge_remove_request.entry.in_charge.all().count() == 1
#         random_entry_in_charge_remove_request.status = EntryInChargeRequestStatus.APPROVED.value
#         random_entry_in_charge_remove_request.save()

#         assert random_entry_in_charge_remove_request.entry.in_charge.all().count() == 0