def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs['return'] = ret kwargs['tables'] = [] for resource in ret.return_type.resources: resource_name = resource.get('name') schema = Schema(resource.get('schema')) headers = [{"title": f.name, "required": f.required} for f in schema.fields] table = {'name': resource_name, 'title': resource.get('title', resource.get('name')), 'headers': headers} try: return_table = ret.returntable_set.get(name=resource_name) rows = [return_row.data for return_row in return_table.returnrow_set.all()] validated_rows = list(schema.rows_validator(rows)) table['data'] = validated_rows except ReturnTable.DoesNotExist: pass kwargs['tables'].append(table) kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm() return super(EnterReturnView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs["return"] = ret kwargs["tables"] = [] for resource in ret.return_type.resources: resource_name = resource.get("name") schema = Schema(resource.get("schema")) headers = [] for f in schema.fields: header = {"title": f.name, "required": f.required} if f.is_species: header["species"] = f.species_type headers.append(header) table = {"name": resource_name, "title": resource.get("title", resource.get("name")), "headers": headers} try: return_table = ret.returntable_set.get(name=resource_name) rows = [return_row.data for return_row in return_table.returnrow_set.all()] validated_rows = list(schema.rows_validator(rows)) table["data"] = validated_rows except ReturnTable.DoesNotExist: pass kwargs["tables"].append(table) if "upload_spreadsheet_form" not in kwargs: kwargs["upload_spreadsheet_form"] = UploadSpreadsheetForm() kwargs["nil_return_form"] = NilReturnForm() return super(EnterReturnView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs['return'] = serialize(ret, posthook=format_return) kwargs['tables'] = [] for resource in ret.return_type.resources: resource_name = resource.get('name') schema = Schema(resource.get('schema')) table = {'name': resource_name, 'title': resource.get('title', resource.get('name')), 'headers': schema.headers} try: return_table = ret.returntable_set.get(name=resource_name) rows = [return_row.data for return_row in return_table.returnrow_set.all()] validated_rows = list(schema.rows_validator(rows)) table['data'] = validated_rows except ReturnTable.DoesNotExist: pass kwargs['tables'].append(table) kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm() if ret.proxy_customer is None: to = ret.licence.holder else: to = ret.proxy_customer kwargs['log_entry_form'] = CommunicationsLogEntryForm(to=to.get_full_name(), fromm=self.request.user.get_full_name()) return super(CurateReturnView, self).get_context_data(**kwargs)
def _is_post_data_valid(ret, tables_info, post_data): for table in tables_info: table_rows = _get_table_rows_from_post(table.get("name"), post_data) if len(table_rows) == 0: return False schema = Schema(ret.return_type.get_schema_by_name(table.get("name"))) if not schema.is_all_valid(table_rows): return False return True
def _is_post_data_valid(ret, tables_info, post_data): for table in tables_info: table_rows = _get_table_rows_from_post(table.get('name'), post_data) if len(table_rows) == 0: return False schema = Schema(ret.return_type.get_schema_by_name(table.get('name'))) if not schema.is_all_valid(table_rows): return False return True
def setUp(self): self.schema_descriptor = { "fields": [ { "type": "string", "name": "DATUM", "constraints": { "required": True, "enum": ["GDA94", "WGS84", "AGD84", "AGD66"] }, }, { "type": "number", "name": "LATITUDE", "constraints": { "minimum": -60.0, "maximum": 0, "required": True } }, { "type": "number", "name": "LONGITUDE", "constraints": { "minimum": 80.0, "maximum": 170.0, "required": True } }, { "type": "number", "name": "ZONE", "constraints": { "required": True, "enum": [49, 50, 51, 52] } }, { "type": "number", "name": "EASTING", "constraints": { "required": True, } }, { "type": "number", "name": "NORTHING", "constraints": { "required": True, } }, ] } self.schema = Schema(self.schema_descriptor) self.assertTrue(self.schema.is_lat_long_easting_northing_schema())
def test_species_by_wl_tag(self): # adding a wl species tag to a field turns it into a species field (whatever its name) descriptor = clone(helpers.GENERIC_SCHEMA) sch = Schema(descriptor) # no species field self.assertFalse(sch.species_fields) # tag field = descriptor['fields'][0] field['wl'] = {'type': 'species'} sch = Schema(descriptor) self.assertEqual(1, len(sch.species_fields)) self.assertEquals(field['name'], sch.species_fields[0].name)
def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs['return'] = ret kwargs['tables'] = [] for resource in ret.return_type.resources: resource_name = resource.get('name') schema = Schema(resource.get('schema')) table = { 'name': resource_name, 'title': resource.get('title', resource.get('name')), 'headers': schema.headers } try: return_table = ret.returntable_set.get(name=resource_name) table['data'] = [ return_row.data for return_row in return_table.returnrow_set.all() ] except ReturnTable.DoesNotExist: pass kwargs['tables'].append(table) return super(ViewReturnReadonlyView, self).get_context_data(**kwargs)
def get(self, request, *args, **kwargs): return_type = get_object_or_404(ReturnType, pk=kwargs.get('return_type_pk')) # for API purpose, increase the session timeout set_api_session_timeout(request) resource_number = kwargs.get('resource_number') if not resource_number: resource_number = 0 else: resource_number = int(resource_number) all_resources = return_type.resources if resource_number >= len(all_resources): raise Http404( "Invalid resource number {}. The Return Type {} has only {} resources" .format(resource_number, return_type.licence_type, len(all_resources))) resource_name = return_type.get_resources_names()[resource_number] qs = ReturnRow.objects.filter(return_table__name=resource_name) schema = Schema(return_type.get_schema_by_name(resource_name)) response = HttpResponse(content_type='text/csv') file_name = 'wl_returns_{}.csv'.format(resource_name) response['Content-Disposition'] = 'attachment; filename={}'.format( file_name) writer = csv.writer(response) writer.writerow(schema.headers) for ret_row in qs: row = [] for field in schema.field_names: row.append( smart_text(ret_row.data.get(field, ''), errors='replace')) writer.writerow(row) return response
def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs['return'] = ret kwargs['tables'] = [] for resource in ret.return_type.resources: resource_name = resource.get('name') schema = Schema(resource.get('schema')) headers = [] for f in schema.fields: header = { "title": f.name, "required": f.required } if f.is_species: header["species"] = f.species_type headers.append(header) table = { 'name': resource_name, 'title': resource.get('title', resource.get('name')), 'headers': headers } try: return_table = ret.returntable_set.get(name=resource_name) rows = [return_row.data for return_row in return_table.returnrow_set.all()] validated_rows = list(schema.rows_validator(rows)) table['data'] = validated_rows except ReturnTable.DoesNotExist: pass kwargs['tables'].append(table) if 'upload_spreadsheet_form' not in kwargs: kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm() kwargs['nil_return_form'] = NilReturnForm() pending_amendments = ret.pending_amendments_qs if pending_amendments: kwargs['amendments'] = pending_amendments return super(EnterReturnView, self).get_context_data(**kwargs)
def get_context_data(self, **kwargs): ret = get_object_or_404(Return, pk=self.args[0]) kwargs['return'] = serialize(ret, posthook=format_return) kwargs['tables'] = [] for resource in ret.return_type.resources: resource_name = resource.get('name') schema = Schema(resource.get('schema')) table = { 'name': resource_name, 'title': resource.get('title', resource.get('name')), 'headers': schema.headers } try: return_table = ret.returntable_set.get(name=resource_name) rows = [ return_row.data for return_row in return_table.returnrow_set.all() ] validated_rows = list(schema.rows_validator(rows)) table['data'] = validated_rows except ReturnTable.DoesNotExist: pass kwargs['tables'].append(table) kwargs['upload_spreadsheet_form'] = UploadSpreadsheetForm() if ret.proxy_customer is None: to = ret.licence.holder else: to = ret.proxy_customer kwargs['log_entry_form'] = ReturnsLogEntryForm( to=to.get_full_name(), fromm=self.request.user.get_full_name(), ) return super(CurateReturnView, self).get_context_data(**kwargs)
def test_species_by_field_name(self): """ A previous implementation supported species field detection by just the field name. Not anymore :return: """ names = [ 'species name', 'Species Name', 'SPECIES_NAME', 'species_Name' ] for name in names: descriptor = clone(helpers.GENERIC_SCHEMA) sch = Schema(descriptor) # no species field self.assertFalse(sch.species_fields) # add a field named name field = clone(BASE_FIELD) field['name'] = name descriptor['fields'].append(field) sch = Schema(descriptor) self.assertEqual(0, len(sch.species_fields))
def post(self, request, *args, **kwargs): context = self.get_context_data() ret = context['return'] if 'upload' in request.POST: form = UploadSpreadsheetForm(request.POST, request.FILES) if form.is_valid(): temp_file_dir = tempfile.mkdtemp(dir=settings.MEDIA_ROOT) try: data = form.cleaned_data.get('spreadsheet_file') path = default_storage.save(os.path.join(temp_file_dir, str(data)), ContentFile(data.read())) workbook = excel.load_workbook_content(path) for table in context['tables']: worksheet = excel.get_sheet(workbook, table.get('title')) \ or excel.get_sheet(workbook, table.get('name')) if worksheet is not None: table_data = excel.TableData(worksheet) schema = Schema(ret.return_type.get_schema_by_name(table.get('name'))) validated_rows = list(schema.rows_validator(table_data.rows_by_col_header_it())) table['data'] = validated_rows else: messages.warning(request, 'Missing worksheet ' + table.get('name')) finally: shutil.rmtree(temp_file_dir) elif 'draft' in request.POST or 'draft_continue' in request.POST: _create_return_data_from_post_data(ret, context['tables'], request.POST) if is_officer(request.user): ret.proxy_customer = request.user ret.status = 'draft' ret.save() messages.warning(request, 'Return saved as draft.') # redirect or reshow page depending on whether save or save/continue was clicked if 'draft' in request.POST: return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) elif 'lodge' in request.POST: if _is_post_data_valid(ret, context['tables'], request.POST): _create_return_data_from_post_data(ret, context['tables'], request.POST) self._set_submitted(ret) return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) if len(table['data']) == 0: messages.warning(request, "You must enter data for {} or submit a Nil Return".format(table.get('name'))) elif 'nil' in request.POST: form = NilReturnForm(request.POST) if form.is_valid(): ret.nil_return = True ret.comments = form.cleaned_data['comments'] self._set_submitted(ret) return redirect('home') return render(request, self.template_name, context)
def _get_validated_rows_from_post(ret, table_name, post_data): rows = _get_table_rows_from_post(table_name, post_data) schema = Schema(ret.return_type.get_schema_by_name(table_name)) return list(schema.rows_validator(rows))
def post(self, request, *args, **kwargs): context = self.get_context_data() ret = context['return'] if 'upload' in request.POST: form = UploadSpreadsheetForm(request.POST, request.FILES) if form.is_valid(): temp_file_dir = tempfile.mkdtemp(dir=settings.MEDIA_ROOT) try: data = form.cleaned_data.get('spreadsheet_file') path = default_storage.save(os.path.join(temp_file_dir, str(data)), ContentFile(data.read())) workbook = excel.load_workbook_content(path) for table in context['tables']: worksheet = excel.get_sheet(workbook, table.get('title')) \ or excel.get_sheet(workbook, table.get('name')) if worksheet is not None: table_data = excel.TableData(worksheet) schema = Schema(ret.return_type.get_schema_by_name(table.get('name'))) validated_rows = list(schema.rows_validator(table_data.rows_by_col_header_it())) table['data'] = validated_rows else: messages.warning(request, 'Missing worksheet ' + table.get('name')) finally: shutil.rmtree(temp_file_dir) elif 'draft' in request.POST or 'draft_continue' in request.POST: _create_return_data_from_post_data(ret, context['tables'], request.POST) if is_officer(request.user): ret.proxy_customer = request.user ret.status = 'draft' ret.save() messages.warning(request, 'Return saved as draft.') # redirect or reshow page depending on whether save or save/continue was clicked if 'draft' in request.POST: return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) elif 'lodge' in request.POST: if _is_post_data_valid(ret, context['tables'], request.POST): _create_return_data_from_post_data(ret, context['tables'], request.POST) ret.lodgement_number = '%s-%s' % (str(ret.licence.licence_type.pk).zfill(LICENCE_TYPE_NUM_CHARS), str(ret.pk).zfill(LODGEMENT_NUMBER_NUM_CHARS)) ret.lodgement_date = date.today() if is_officer(request.user): ret.proxy_customer = request.user ret.status = 'submitted' ret.save() message = 'Return successfully submitted.' # update next return in line's status to become the new current return next_ret = Return.objects.filter(licence=ret.licence, status='future').order_by('due_date').first() if next_ret is not None: next_ret.status = 'current' next_ret.save() message += ' The next return for this licence can now be entered and is due on {}.'.\ format(next_ret.due_date.strftime(DATE_FORMAT)) return_submitted.send(sender=self.__class__, ret=ret) messages.success(request, message) return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) if len(table['data']) == 0: messages.warning(request, "You must enter data for {}".format(table.get('name'))) return render(request, self.template_name, context)
def post(self, request, *args, **kwargs): context = self.get_context_data() ret = context['return'] if 'upload' in request.POST: form = UploadSpreadsheetForm(request.POST, request.FILES) if form.is_valid(): temp_file_dir = tempfile.mkdtemp(dir=settings.MEDIA_ROOT) try: data = form.cleaned_data.get('spreadsheet_file') path = default_storage.save(os.path.join(temp_file_dir, str(data)), ContentFile(data.read())) workbook = excel.load_workbook_content(path) for table in context['tables']: worksheet = excel.get_sheet(workbook, table.get('title')) \ or excel.get_sheet(workbook, table.get('name')) if worksheet is not None: table_data = excel.TableData(worksheet) schema = Schema(ret.return_type.get_schema_by_name(table.get('name'))) excel_rows = list(table_data.rows_by_col_header_it()) has_errors = not schema.is_all_valid(excel_rows) if has_errors: messages.error(request, "Your return contains some errors. See below.") validated_rows = list(schema.rows_validator(excel_rows)) # We want to stringify the datetime/date that might have been created by the excel parser for vr in validated_rows: for col, validation in vr.items(): value = validation.get('value') if isinstance(value, datetime.datetime) or isinstance(value, datetime.date): validation['value'] = value.strftime(DATE_FORMAT) table['data'] = validated_rows else: messages.warning(request, 'Missing worksheet ' + table.get('name')) finally: shutil.rmtree(temp_file_dir) else: context['upload_spreadsheet_form'] = form elif 'draft' in request.POST or 'draft_continue' in request.POST: _create_return_data_from_post_data(ret, context['tables'], request.POST) if is_officer(request.user): ret.proxy_customer = request.user ret.status = 'draft' ret.save() messages.warning(request, 'Return saved as draft.') # redirect or reshow page depending on whether save or save/continue was clicked if 'draft' in request.POST: return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) elif 'lodge' in request.POST: if _is_post_data_valid(ret, context['tables'], request.POST): _create_return_data_from_post_data(ret, context['tables'], request.POST) self._set_submitted(ret) return redirect('home') else: for table in context['tables']: table['data'] = _get_validated_rows_from_post(ret, table.get('name'), request.POST) if len(table['data']) == 0: messages.warning(request, "You must enter data for {} or submit a Nil Return".format(table.get('name'))) else: messages.error(request, "Your return contains some errors. See below.") elif 'nil' in request.POST: form = NilReturnForm(request.POST) if form.is_valid(): ret.nil_return = True ret.comments = form.cleaned_data['comments'] self._set_submitted(ret) return redirect('home') return render(request, self.template_name, context)
def post(self, request, *args, **kwargs): context = self.get_context_data() ret = context["return"] if "upload" in request.POST: form = UploadSpreadsheetForm(request.POST, request.FILES) if form.is_valid(): temp_file_dir = tempfile.mkdtemp(dir=settings.MEDIA_ROOT) try: data = form.cleaned_data.get("spreadsheet_file") path = default_storage.save(os.path.join(temp_file_dir, str(data)), ContentFile(data.read())) workbook = excel.load_workbook_content(path) for table in context["tables"]: worksheet = excel.get_sheet(workbook, table.get("title")) or excel.get_sheet( workbook, table.get("name") ) if worksheet is not None: table_data = excel.TableData(worksheet) schema = Schema(ret.return_type.get_schema_by_name(table.get("name"))) excel_rows = list(table_data.rows_by_col_header_it()) validated_rows = list(schema.rows_validator(excel_rows)) # We want to stringify the datetime/date that might have been created by the excel parser for vr in validated_rows: for col, validation in vr.items(): value = validation.get("value") if isinstance(value, datetime.datetime) or isinstance(value, datetime.date): validation["value"] = value.strftime(DATE_FORMAT) table["data"] = validated_rows else: messages.warning(request, "Missing worksheet " + table.get("name")) finally: shutil.rmtree(temp_file_dir) else: context["upload_spreadsheet_form"] = form elif "draft" in request.POST or "draft_continue" in request.POST: _create_return_data_from_post_data(ret, context["tables"], request.POST) if is_officer(request.user): ret.proxy_customer = request.user ret.status = "draft" ret.save() messages.warning(request, "Return saved as draft.") # redirect or reshow page depending on whether save or save/continue was clicked if "draft" in request.POST: return redirect("home") else: for table in context["tables"]: table["data"] = _get_validated_rows_from_post(ret, table.get("name"), request.POST) elif "lodge" in request.POST: if _is_post_data_valid(ret, context["tables"], request.POST): _create_return_data_from_post_data(ret, context["tables"], request.POST) self._set_submitted(ret) return redirect("home") else: for table in context["tables"]: table["data"] = _get_validated_rows_from_post(ret, table.get("name"), request.POST) if len(table["data"]) == 0: messages.warning( request, "You must enter data for {} or submit a Nil Return".format(table.get("name")) ) elif "nil" in request.POST: form = NilReturnForm(request.POST) if form.is_valid(): ret.nil_return = True ret.comments = form.cleaned_data["comments"] self._set_submitted(ret) return redirect("home") return render(request, self.template_name, context)
class TestLatLongEastingNorthingCase(TestCase): """ Test the conditional requirement between long/lat and easting/northing. One or the other must be required. """ def setUp(self): self.schema_descriptor = { "fields": [ { "type": "string", "name": "DATUM", "constraints": { "required": True, "enum": ["GDA94", "WGS84", "AGD84", "AGD66"] }, }, { "type": "number", "name": "LATITUDE", "constraints": { "minimum": -60.0, "maximum": 0, "required": True } }, { "type": "number", "name": "LONGITUDE", "constraints": { "minimum": 80.0, "maximum": 170.0, "required": True } }, { "type": "number", "name": "ZONE", "constraints": { "required": True, "enum": [49, 50, 51, 52] } }, { "type": "number", "name": "EASTING", "constraints": { "required": True, } }, { "type": "number", "name": "NORTHING", "constraints": { "required": True, } }, ] } self.schema = Schema(self.schema_descriptor) self.assertTrue(self.schema.is_lat_long_easting_northing_schema()) def test_lat_long_only(self): """ Lat/Long + datum should not generate an error :return: """ data = { "DATUM": "WGS84", "LATITUDE": -32, "LONGITUDE": 116, "EASTING": None, "NORTHING": None, "ZONE": None } self.assertTrue(self.schema.is_row_valid(data)) # datum always required data = { "DATUM": None, "LATITUDE": -32, "LONGITUDE": 116, "EASTING": None, "NORTHING": None, "ZONE": None } self.assertFalse(self.schema.is_row_valid(data)) errors = self.schema.get_error_fields(data) self.assertEqual(len(errors), 1) self.assertEqual('DATUM', errors[0][0]) def test_east_north_only(self): """ Northing/Easting + Datum + Zone should be valid :return: """ data = { "DATUM": "WGS84", "LATITUDE": None, "LONGITUDE": None, "EASTING": 123456, "NORTHING": 654321, "ZONE": 50 } self.assertTrue(self.schema.is_row_valid(data)) # datum always required data = { "DATUM": None, "LATITUDE": None, "LONGITUDE": None, "EASTING": 123456, "NORTHING": 654321, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) errors = self.schema.get_error_fields(data) self.assertEqual(len(errors), 1) self.assertEqual('DATUM', errors[0][0]) # ZONE always required data = { "DATUM": "WGS84", "LATITUDE": None, "LONGITUDE": None, "EASTING": 123456, "NORTHING": 654321, "ZONE": '' } self.assertFalse(self.schema.is_row_valid(data)) errors = self.schema.get_error_fields(data) self.assertEqual(len(errors), 1) self.assertEqual('ZONE', errors[0][0]) def test_no_lat_long_and_no_east_north(self): data = { "DATUM": "WGS84", "LATITUDE": '', "LONGITUDE": '', "EASTING": None, "NORTHING": None, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertTrue('LATITUDE' in error_fields) self.assertTrue('LONGITUDE' in error_fields) self.assertTrue('EASTING' in error_fields) self.assertTrue('NORTHING' in error_fields) def test_half_baked_data(self): """ Missing either lat or long ot east or north :return: """ data = { "DATUM": "WGS84", "LATITUDE": -32, "LONGITUDE": None, "EASTING": None, "NORTHING": None, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertFalse('LATITUDE' in error_fields) self.assertTrue('NORTHING' in error_fields) self.assertTrue('LONGITUDE' in error_fields) self.assertTrue('EASTING' in error_fields) data = { "DATUM": "WGS84", "LATITUDE": None, "LONGITUDE": 115, "EASTING": None, "NORTHING": None, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertFalse('LONGITUDE' in error_fields) self.assertTrue('EASTING' in error_fields) self.assertTrue('LATITUDE' in error_fields) self.assertTrue('NORTHING' in error_fields) data = { "DATUM": "WGS84", "LATITUDE": None, "LONGITUDE": None, "EASTING": 123456, "NORTHING": None, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertTrue('LONGITUDE' in error_fields) self.assertFalse('EASTING' in error_fields) self.assertTrue('LATITUDE' in error_fields) self.assertTrue('NORTHING' in error_fields) data = { "DATUM": "WGS84", "LATITUDE": None, "LONGITUDE": None, "EASTING": None, "NORTHING": 645321, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertFalse('NORTHING' in error_fields) self.assertTrue('LATITUDE' in error_fields) self.assertTrue('LONGITUDE' in error_fields) self.assertTrue('EASTING' in error_fields) def test_mixed_data(self): """ Test that data that mixed lat/long and noth/east are not valid E.g provide lat but not long and provide easting but not northing :return: """ data = { "DATUM": "WGS84", "LATITUDE": -32, "LONGITUDE": None, "EASTING": 12345, "NORTHING": None, "ZONE": 50 } self.assertFalse(self.schema.is_row_valid(data)) error_fields = [e[0] for e in self.schema.get_error_fields(data)] self.assertFalse('LATITUDE' in error_fields) self.assertFalse('EASTING' in error_fields) self.assertTrue('LONGITUDE' in error_fields) self.assertTrue('NORTHING' in error_fields)
def test_no_species(self): descriptor = clone(helpers.GENERIC_SCHEMA) sch = Schema(descriptor) # no species field self.assertFalse(sch.species_fields)