def test_case_serializable(self):
# TODO >> With post processing FS
f = os.path.join(RESOURCE_DIR, 'serialized_case.json')
a = Case(file_number='ABC/123', date=date(year=2000, month=10, day=2))
a_json = a.to_json(f)
b = Case.from_json_file(f)
b_json = b.to_json()
self.assertEqual(a_json, b_json)
def test_field_validation(self):
try:
# max_length
t = 'A' * 201
c = Case(title=t, file_number=t)
c.save()
raise ValueError('DataError should have been raised.')
except DataError:
pass
def from_json_file(self, f):
logger.debug('Test resource: %s' % f)
case = Case.from_json_file(f)
case.full_clean()
case.save()
self.assertGreaterEqual(len(case.text), 300,
'Case text is too short: %s' % case.text)
logger.debug('Test OK: %s' % case)
def test_field_validation_2(self):
try:
# max_length
t = 'A' * 201
c = Case(title=t, file_number=t)
c.full_clean()
# c.save()
raise ValueError('ValidationError should have been raised.')
except ValidationError:
pass
def test_raise_error_from_json_file(self):
directory = os.path.join(RESOURCE_DIR, 'invalid_cases')
for f in os.listdir(directory):
f = os.path.join(directory, f)
logger.debug('Test resource: %s' % f)
try:
Case.from_json_file(f)
raise ValueError('ProcessingError not raised with %s' % f)
except ProcessingError:
pass
def test_assign_court(self):
class TestCourtTypes(CourtTypes):
def get_types(self):
return {
'AG': {
'name': 'Amtsgericht',
'levels': [CourtLocationLevel.CITY]
},
}
with self.settings(COURT_TYPES=TestCourtTypes()):
unprocessed = Case.objects.get(pk=1)
self.assertEqual(Court.DEFAULT_ID, unprocessed.pk,
'Unprocessed case has already assigned court')
case = AssignCourt().process(unprocessed)
self.assertEqual(1166, case.court.pk, 'Invalid court id')
self.assertEqual('EuGH', case.court.code, 'Invalid court code')
with_city = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-city',
court_raw=json.dumps({
'name': 'Amtsgericht Aalen',
})))
self.assertEqual(1173, with_city.court.pk, 'Invalid court id')
#
with_chamber = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-chamber',
court_raw=json.dumps({
'name':
'Bundesverfassungsgericht 5. Kammer',
})))
self.assertEqual(1167, with_chamber.court.pk, 'Invalid court id')
not_found = AssignCourt().process(
Case(court_id=2,
file_number='with-chamber',
court_raw=json.dumps({
'name': 'Some other court',
})))
self.assertEqual(Court.DEFAULT_ID, not_found.court_id,
'Invalid court id')
def short_url_view(request, pk):
"""
Redirects to detail view
"""
item = get_object_or_404(Case.get_queryset(request).only('slug'), pk=pk)
return redirect(item.get_absolute_url(), permanent=True)
class CaseAnnotationSerializer(serializers.ModelSerializer):
belongs_to = serializers.PrimaryKeyRelatedField(
queryset=Case.get_queryset().defer(
*Case.defer_fields_list_view).select_related('court'),
html_cutoff=10,
)
label = serializers.PrimaryKeyRelatedField(
queryset=AnnotationLabel.objects.all().select_related('owner'),
html_cutoff=10,
)
class Meta:
model = CaseAnnotation
fields = '__all__'
def validate(self, attrs):
instance = self.Meta.model(**attrs)
# Work-around to show fields in error response
try:
instance.clean()
except ValidationError as e:
raise serializers.ValidationError(e.args[0])
return attrs
def case_view(request, case_slug):
"""
Case detail view
"""
qs = Case.get_queryset(request).select_related('court').select_related(
'source')
item = get_object_or_404(qs, slug=case_slug)
# Load annotations for staff users
if request.user.is_staff:
marker_labels = item.get_markers(request)\
.values('label__id', 'label__name', 'label__color', 'label__private')\
.annotate(count=Count('label'))\
.order_by('count')
annotation_labels = item.get_annotation_labels(request)
else:
marker_labels = None
annotation_labels = None
return render(
request, 'cases/case.html', {
'title': item.get_title(),
'item': item,
'content': item.get_content_as_html(request),
'annotation_labels': annotation_labels,
'marker_labels': marker_labels,
'line_counter': Counter(),
'nav': 'cases',
})
def test_extract_law_and_case_refs_2(self):
unprocessed = Case.from_json_file(
os.path.join(RESOURCE_DIR, 'extract_refs/2.json'))
case = ExtractRefs(law_refs=True, case_refs=True).process(unprocessed)
# TODO Old validated value: 56
self.assertEqual(62, len(case.reference_markers),
'Invalid number of references')
def test_extract_law_refs_1(self):
unprocessed = Case.from_json_file(
os.path.join(RESOURCE_DIR, 'extract_refs/1.json'))
case = ExtractRefs(law_refs=True, case_refs=False).process(unprocessed)
# TODO Validate test - old value: 33
self.assertEqual(33, len(case.reference_markers),
'Invalid number of references')
def get_queryset(self):
# Get cases that belong to court
queryset = Case.get_queryset(self.request)\
.select_related('court')\
.defer(*Case.defer_fields_list_view)\
.filter(court=self.court)\
.order_by('-date')
return queryset
def test_assign_court_umlauts(self):
#
case_with_umlauts = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-umlauts',
court_raw='{"name": "Europ\u00e4ischer Gerichtshof 9. Senat"}'
))
self.assertEqual(1166, case_with_umlauts.court_id)
def index_view(request):
law_books = LawBook.objects.filter(latest=True).order_by('-order')
cases = Case.get_queryset(request)\
.defer(*Case.defer_fields_list_view)\
.select_related('court')\
.order_by('-updated_date')
laws_count = '{:,}'.format(Law.objects.all().count())
cases_count = '{:,}'.format(Case.get_queryset(request).count())
return render(request, 'homepage/index.html', {
'title': _('Free Access to Legal Data'),
'nav': 'homepage',
'law_books': law_books,
'cases': cases,
'laws_count': laws_count,
'cases_count': cases_count,
})
def case_view(request, case_slug):
item = get_object_or_404(Case.get_queryset(request), slug=case_slug)
return render(
request, 'cases/case.html', {
'title': item.get_title(),
'item': item,
'line_counter': Counter(),
'nav': 'cases',
'is_read_more': is_read_more
})
def case_view(request, case_slug):
item = get_object_or_404(Case.get_queryset(request), slug=case_slug)
return render(request, 'cases/case.html', {
'title': item.get_title(),
'item': item,
'content': item.get_content_as_html(request),
'annotation_labels': item.get_annotation_labels(request) if request.user.is_staff else None,
'line_counter': Counter(),
'nav': 'cases',
})
def __init__(self):
super().__init__(
{
'queryset':
Case.get_queryset().select_related('court').defer(
*Case.defer_fields_list_view).order_by('-updated_date'),
'date_field':
'updated_date'
},
priority=1.0,
changefreq='daily')
def test_assign_court(self):
unprocessed = Case.objects.get(pk=1)
self.assertEqual(Court.DEFAULT_ID, unprocessed.pk,
'Unprocessed case has already assigned court')
case = AssignCourt().process(unprocessed)
self.assertEqual(1166, case.court.pk, 'Invalid court id')
self.assertEqual('EuGH', case.court.code, 'Invalid court code')
with_city = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-city',
court_raw=json.dumps({
'name': 'Amtsgericht Aalen',
})))
self.assertEqual(1173, with_city.court.pk, 'Invalid court id')
#
with_chamber = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-chamber',
court_raw=json.dumps({
'name':
'Bundesverfassungsgericht 5. Kammer',
})))
self.assertEqual(1167, with_chamber.court.pk, 'Invalid court id')
not_found = AssignCourt().process(
Case(court_id=2,
file_number='with-chamber',
court_raw=json.dumps({
'name': 'Some other court',
})))
self.assertEqual(Court.DEFAULT_ID, not_found.court_id,
'Invalid court id')
def index_view(request):
k = 10
books = LawBook.objects.filter(latest=True).order_by('-revision_date')[:k]
cases = Case.get_queryset(request).order_by('-updated_date')[:k]
return render(
request, 'homepage/index.html', {
'title': _('Free Access to Legal Data'),
'nav': 'homepage',
'books': books,
'cases': cases
})
def view_law(request, law_slug, book_slug):
book = get_law_book(request, book_slug)
item = get_object_or_404(Law.objects.select_related('book', 'previous'),
slug=law_slug,
book=book)
referencing_cases = item.get_referencing_cases(
Case.get_queryset(request).defer(*Case.defer_fields_list_view))
return render(
request, 'laws/law.html', {
'nav': 'laws',
'item': item,
'title': item.get_title(),
'referencing_cases': referencing_cases,
})
def index_view(request):
items = Case.get_queryset(request).order_by('-date')
paginator = Paginator(items, 50) # 50 items per page
page = request.GET.get('page')
try:
items = paginator.page(page)
except PageNotAnInteger:
items = paginator.page(1)
except EmptyPage:
items = paginator.page(paginator.num_pages)
return render(request, 'cases/index.html', {
'title': _('Cases'),
'items': items,
'nav': 'cases'
})
def test_from_hit(self):
search_hit = {
'title': 'Case title',
'slug': 'some-slug',
'court': Court.DEFAULT_ID,
'date': '2017-01-01',
'file_number': 'AB/123',
'type': 'Urteil',
'source_url': 'http://openjur.de',
'pdf_url': 'http://',
'text': 'Some case text, lorem ipsum.'
}
c = Case.from_hit(search_hit)
self.assertEqual(c.get_court().get_id(), Court.DEFAULT_ID,
'Invalid court id')
self.assertEqual(c.file_number, 'AB/123', 'Invalid file number')
def test_extract_law_and_case_refs_3(
self): # TODO Requires more law book BauGB
"""
Assert:
(vgl. Schl.-Holst. OVG, Urteil vom 19.01.2012 - 1 LB 11/11 -, juris [Rn. 23 f.])
(vgl. OVG NRW, Urteil vom 10.10.1996 - 7 A 4185/95 -, juris [Rn. 68])
(vgl. BVerwG, Beschluss vom 12.11.1987 - 4 B 216/87 -, juris [Rn. 2]; VGH BW, Urteil vom 10.01.2007 - 3 S 1251/06 -, juris [Rn. 25])
(so BVerfG in std. Rspr., vgl. z.B. BVerfG, Beschluss vom 23.07.2003 –- 2 BvR 624/01 -, juris [Rn. 16 f.])
:return:
"""
unprocessed = Case.from_json_file(
os.path.join(RESOURCE_DIR, 'extract_refs/3.json'))
case = ExtractRefs(law_refs=True, case_refs=True).process(unprocessed)
self.assertEqual(5, len(case.reference_markers),
'Invalid number of references')
def test_assign_court_umlauts(self):
class TestCourtTypes(CourtTypes):
def get_types(self):
return {
'EuGH': {
'name': 'Europäischer Gerichtshof',
'levels': []
}
}
with self.settings(COURT_TYPES=TestCourtTypes()):
case_with_umlauts = AssignCourt().process(
Case(court_id=Court.DEFAULT_ID,
file_number='with-umlauts',
court_raw=
'{"name": "Europ\u00e4ischer Gerichtshof 9. Senat"}'))
self.assertEqual(1166, case_with_umlauts.court_id)
def test_case_serializable(self):
# TODO >> With post processing FS
file_path = os.path.join(settings.WORKING_DIR, 'serialized_case.json')
a = Case(file_number='ABC/123', date=date(year=2000, month=10, day=2))
a.save()
a_json = a.to_json(file_path)
b = Case.from_json_file(file_path)
b_json = b.to_json()
# Clean up again
os.remove(file_path)
# Compare
self.assertEqual(a_json, b_json)
class CaseViewSet(viewsets.ModelViewSet):
"""
List view for cases
"""
pagination_class = SmallResultsSetPagination # limit page (other content field blows up response size)
queryset = Case.get_queryset()
serializer_class = CaseSerializer
# lookup_field = 'slug'
filter_backends = (OrderingFilter, DjangoFilterBackend, )
filterset_class = CaseAPIFilter
ordering_fields = ('date', )
@method_decorator(cache_page(60))
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_queryset(self):
return Case.get_queryset()\
.select_related('court')\
.only(*CASE_API_FIELDS)
def test_extract_case_refs_from_juris(self):
fixtures = [
{
'file': '1.json',
'ref_count': 8, # TODO verify number
},
{
'file': '2.json',
'ref_count': 5, # TODO verify number
},
{
'file': '3.json',
'ref_count': 5, # Correct number
}
]
for f in fixtures:
unprocessed = Case.from_json_file(
os.path.join(RESOURCE_DIR, 'extract_refs/juris/' + f['file']))
case = ExtractRefs(law_refs=False,
case_refs=True).process(unprocessed)
self.assertEqual(f['ref_count'], len(case.reference_markers),
'Invalid number of references: %s' % f)
class CasesModelsTestCase(TestCase):
fixtures = [
'locations/countries.json', 'locations/states.json',
'locations/cities.json', 'courts/courts.json'
]
def setUp(self):
# CourtsTestCase.set_up_courts()
pass
def tearDown(self):
# CourtsTestCase.tear_down_courts()
pass
def test_slug(self):
Case.objects.create(pk=1,
file_number='AB/123',
slug='a-case-slug',
court_id=Court.DEFAULT_ID)
self.assertEqual(
Case.objects.get(slug='a-case-slug').pk, 1,
'Cannot get case by slug')
def test_field_validation_2(self):
try:
# max_length
t = 'A' * 201
c = Case(title=t, file_number=t)
c.full_clean()
# c.save()
raise ValueError('ValidationError should have been raised.')
except ValidationError:
pass
@mysql_only_test
def test_field_validation(self):
try:
# max_length
t = 'A' * 201
c = Case(title=t, file_number=t)
c.save()
raise ValueError('DataError should have been raised.')
except DataError:
pass
def from_json_directory(self, directory):
"""Test from_json_file method with different sources"""
test_files = os.listdir(os.path.join(RESOURCE_DIR, directory))
for f in test_files:
f = os.path.join(RESOURCE_DIR, directory, f)
self.from_json_file(f)
def from_json_file(self, f):
logger.debug('Test resource: %s' % f)
case = Case.from_json_file(f)
case.full_clean()
case.save()
self.assertGreaterEqual(len(case.text), 300,
'Case text is too short: %s' % case.text)
logger.debug('Test OK: %s' % case)
@skip # TODO fixtures need to fit to test files
def test_from_json_file_bgh(self):
self.from_json_directory('from_bgh')
@skip # TODO write with django serializer
def test_section_json(self):
self.from_json_file(
os.path.join(
RESOURCE_DIR,
'from_bverfg/bverfg_incorrect_string_value_in_raw.json'))
# @skip # TODO write with django serializer
def test_raise_error_from_json_file(self):
directory = os.path.join(RESOURCE_DIR, 'invalid_cases')
for f in os.listdir(directory):
f = os.path.join(directory, f)
logger.debug('Test resource: %s' % f)
try:
Case.from_json_file(f)
raise ValueError('ProcessingError not raised with %s' % f)
except ProcessingError:
pass
def test_case_serializable(self):
# TODO >> With post processing FS
file_path = os.path.join(settings.WORKING_DIR, 'serialized_case.json')
a = Case(file_number='ABC/123', date=date(year=2000, month=10, day=2))
a.save()
a_json = a.to_json(file_path)
b = Case.from_json_file(file_path)
b_json = b.to_json()
# Clean up again
os.remove(file_path)
# Compare
self.assertEqual(a_json, b_json)
# case = Case.from_json_file(f)
# self.assertEqual(open(f).read(), case.to_json(), 'JSON should be equal')
# print(case.get_sections())
def test_get_content_as_html(self):
"""Test valid HTML output."""
expected = '<h1>Some html</h1><p>foo</p>'
obj = Case(content=expected)
self.assertEqual(obj.get_content_as_html(), expected,
'Invalid html conversation')
def test_get_short_title(self):
title = 'This is a very long title for an even more long cases to all extend'
case = Case(title=title, file_number='ABC/123')
self.assertEqual(13, len(case.get_short_title(10)), 'Invalid title')
def test_get_absolute_url(self):
case = Case(title='Some titlr', file_number='ABC/123')
self.assertTrue('no-slug' in case.get_absolute_url(), 'Invalid url')
case = Case(title='Some titlr', file_number='ABC/123', slug='abc')
self.assertTrue('abc' in case.get_absolute_url(), 'Invalid url')
def test_get_short_title(self):
title = 'This is a very long title for an even more long cases to all extend'
case = Case(title=title, file_number='ABC/123')
self.assertEqual(13, len(case.get_short_title(10)), 'Invalid title')
def test_get_content_as_html(self):
"""Test valid HTML output."""
expected = '<h1>Some html</h1><p>foo</p>'
obj = Case(content=expected)
self.assertEqual(obj.get_content_as_html(), expected,
'Invalid html conversation')
