def test__idbl_data_serializer__valid():
"""Tests that model is properly created via iDBL serializer."""
# Get initial model counts
drug_count = models.Drug.objects.count()
price_count = models.Price.objects.count()
clients_count = models.Clients.objects.count()
coverage_count = models.CoverageCriteria.objects.count()
special_count = models.SpecialAuthorization.objects.count()
# Create serializer data
idbl_data = create_idbl_data()
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid
assert serializer.is_valid()
# Save the data
serializer.save()
# Confirm data was properly added (by model counts)
assert drug_count + 1 == models.Drug.objects.count()
assert price_count + 1 == models.Price.objects.count()
assert clients_count + 1 == models.Clients.objects.count()
assert coverage_count + 1 == models.CoverageCriteria.objects.count()
assert special_count + 1 == models.SpecialAuthorization.objects.count()
# Confirm data to models was properly added
drug = models.Drug.objects.get(din=idbl_data['din'])
assert drug == instance
def test__idbl_data_serializer__valid__special_authorization():
"""Tests handling of just a valid special_authorization."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'special_authorization': [{
'file_name': 'a',
'pdf_title': 'b',
}]
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Save data
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.special_authorizations.count() == 1
assert price.special_authorizations.last().file_name == 'a'
assert price.special_authorizations.last().pdf_title == 'b'
def test__idbl_data_serializer__valid__coverage_criteria():
"""Tests handling of just a valid coverage_criteria."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'coverage_criteria': [{
'header': 'a',
'criteria': 'b'
}]
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Save data
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.coverage_criteria.count() == 1
assert price.coverage_criteria.last().header == 'a'
assert price.coverage_criteria.last().criteria == 'b'
def test__idbl_data_serializer__valid__clients():
"""Tests handling of just a valid coverage_status."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'clients': {
'group_1': True,
'group_66': False,
'group_19823': False,
'group_19823a': False,
'group_19824': False,
'group_20400': False,
'group_20403': False,
'group_20514': False,
'group_22128': False,
'group_23609': False,
},
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Save data
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.clients.group_1 is True
assert price.clients.group_66 is False
def test__idbl_data_serializer__create_exists():
"""Confirms create method exists."""
serializer = serializers.iDBLDataSerializer(data={})
try:
serializer.is_valid()
serializer.create(serializer.validated_data)
except AttributeError:
assert False
assert True
def test__idbl_data_serializer__get_atc_instance__missing():
"""Tests handling of just a valid atc."""
# Create ATC instances
models.ATC.objects.create(
id='A11BC22',
atc_1='A',
atc_1_text='description 1',
atc_2='A11',
atc_2_text='description 2',
atc_3='A11B',
atc_3_text='description 3',
atc_4='A11BC',
atc_4_text='description 4',
atc_5='A11BC22',
atc_5_text='description 5',
)
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'atc': 'A11BC33',
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid and save serializer
serializer.is_valid()
serializer.save()
# Confirm new ATC was made with proper details
new_atc = models.ATC.objects.get(id='A11BC33')
assert new_atc.atc_1 == 'A'
assert new_atc.atc_1_text == 'description 1'
assert new_atc.atc_2 == 'A11'
assert new_atc.atc_2_text == 'description 2'
assert new_atc.atc_3 == 'A11B'
assert new_atc.atc_3_text == 'description 3'
assert new_atc.atc_4 == 'A11BC'
assert new_atc.atc_4_text == 'description 4'
assert new_atc.atc_5 == 'A11BC33'
assert new_atc.atc_5_text is None
def test__idbl_data_serializer__valid__din():
"""Tests handling of just a valid DIN."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid and save serializer
serializer.is_valid()
drug = serializer.save()
assert drug.din == idbl_data['din']
def test__idbl_data_serializer__valid__schedule():
"""Tests handling of just a valid schedule."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'schedule': 'a',
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Save the data
serializer.is_valid()
drug = serializer.save()
assert drug.schedule == 'a'
def test__idbl_data_serializer__max_lengths_match():
"""Tests that serializer and model max lengths match."""
serializer = serializers.iDBLDataSerializer()
Drug = models.Drug
Price = models.Price
PTC = models.PTC
ATC = models.ATC
bsrf_max_length = (Drug._meta.get_field('brand_name').max_length +
Drug._meta.get_field('strength').max_length +
Drug._meta.get_field('route').max_length +
Drug._meta.get_field('dosage_form').max_length)
assert serializer['din'].max_length == Drug._meta.get_field(
'din').max_length
assert serializer['bsrf'].max_length == bsrf_max_length
assert serializer['ptc'].max_length == PTC._meta.get_field('id').max_length
assert serializer['atc'].max_length == ATC._meta.get_field('id').max_length
assert serializer['unit_price'].max_digits == Price._meta.get_field(
'unit_price').max_digits
assert serializer['unit_price'].decimal_places == Price._meta.get_field(
'unit_price').decimal_places
assert serializer['lca_price'].max_digits == Price._meta.get_field(
'lca_price').max_digits
assert serializer['lca_price'].decimal_places == Price._meta.get_field(
'lca_price').decimal_places
assert serializer['mac_price'].max_digits == Price._meta.get_field(
'mac_price').max_digits
assert serializer['mac_price'].decimal_places == Price._meta.get_field(
'mac_price').decimal_places
assert serializer['mac_text'].max_length == Price._meta.get_field(
'mac_text').max_length
assert serializer['unit_issue'].max_length == Price._meta.get_field(
'unit_issue').max_length
assert serializer['manufacturer'].max_length == Drug._meta.get_field(
'manufacturer').max_length
assert serializer['schedule'].max_length == Drug._meta.get_field(
'schedule').max_length
assert serializer['coverage_status'].max_length == Price._meta.get_field(
'coverage_status').max_length
def test__idbl_data_serializer__valid__interchangeable():
"""Tests handling of just a valid interchangeable."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'interchangeable': True,
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Save data
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.interchangeable is True
def test__idbl_data_serializer__valid__lca_price():
"""Tests handling of just a valid lca_price."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'lca_price': 0.0001,
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid and save serializer
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.lca_price == Decimal('0.0001')
def test__idbl_data_serializer__valid__date_listed():
"""Tests handling of just a valid date_listed."""
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'date_listed': '2019-01-01',
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid and save serializer
serializer.is_valid()
drug = serializer.save()
# Get the price model for this drug
price = drug.prices.last()
assert price.date_listed == datetime(2019, 1, 1).date()
def test__idbl_data_serializer__valid__atc():
"""Tests handling of just a valid atc."""
# Create ATC instance
atc = models.ATC.objects.create(id='1234')
# Create serializer data
idbl_data = {
'abc_id': 1,
'din': '00000001',
'atc': atc.id,
}
# Create initial instance to work from
instance = models.Drug.objects.create(din=idbl_data['din'])
serializer = serializers.iDBLDataSerializer(instance=instance,
data=idbl_data)
# Confirm data is valid and save serializer
serializer.is_valid()
drug = serializer.save()
assert drug.atc == atc