def test_duplicate_entry(self):
'''
Test that duplicate entries by timestamp are not created.
'''
monitor = self.get_bam1022()
payload = {
'Time': timezone.now(),
'AT(C)': '30.60',
'RH(%)': '25.00',
'BP(mmHg)': '764.5',
'ConcRT(ug/m3)': '24',
}
# Create the initial entry
entry = monitor.create_entry(payload)
monitor.process_entry(entry)
entry.save()
# Now call the API with the same payload and verify that it fails.
url = reverse('api:v1:monitors:entry-list',
kwargs={'monitor_id': monitor.pk})
request = self.factory.post(url,
payload,
HTTP_ACCESS_KEY=str(monitor.access_key))
request.monitor = monitor
response = entry_list(request, monitor_id=monitor.pk)
content = get_response_data(response)
assert response.status_code == 400
assert monitor.entries.filter(timestamp=payload['Time']).count() == 1
def test_update_subscription(self):
'''
Test that we can GET the monitor detail endpoint.
'''
Subscription.objects.create(user=self.user,
monitor=self.monitor,
level=Subscription.LEVELS.unhealthy)
payload = {'level': Subscription.LEVELS.hazardous}
url = reverse('api:v1:monitors:alerts:subscribe',
kwargs={'monitor_id': self.monitor.pk})
request = self.factory.post(url, payload)
request.monitor = self.monitor
request.user = self.user
response = subscribe(request, monitor_id=self.monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['data']['monitor'] == str(self.monitor.pk)
assert self.user.subscriptions.filter(
monitor_id=self.monitor.pk,
level=Subscription.LEVELS.hazardous,
).exists()
def test_create_entry(self):
'''
Test that we can create an entry.
'''
monitor = self.get_bam1022()
payload = {
'Time': timezone.now().strftime('%Y-%m-%d %H:%M:%S'),
'AT(C)': '30.6',
'RH(%)': '25.0',
'BP(mmHg)': '764.5',
'ConcRT(ug/m3)': '24',
}
url = reverse('api:v1:monitors:entry-list',
kwargs={'monitor_id': monitor.pk})
request = self.factory.post(url,
payload,
HTTP_ACCESS_KEY=str(monitor.access_key))
request.monitor = monitor
response = entry_list(request, monitor_id=monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['data']['celcius'] == payload['AT(C)']
assert content['data']['fahrenheit'] is not None
entry = Entry.objects.latest('timestamp')
assert entry.is_processed
def test_get_current_time(self):
url = reverse('api:v1:current-time')
request = self.factory.get(url)
response = current_time(request)
assert response.status_code == 200
content = get_response_data(response)
assert isinstance(content, int)
def test_get_sensor_detail(self):
url = reverse('api:v1:sensors:sensor-detail',
kwargs={'sensor_id': self.sensor.pk})
request = self.factory.get(url)
response = sensor_detail(request, sensor_id=self.sensor.pk)
assert response.status_code == 200
content = get_response_data(response)
assert content['data']['id'] == str(self.sensor.pk)
def test_get_sensor_list(self):
url = reverse('api:v1:sensors:sensor-list')
request = self.factory.get(url)
response = sensor_list(request)
assert response.status_code == 200
content = get_response_data(response)
assert str(
self.sensor.pk) in [sensor['id'] for sensor in content['data']]
def test_monitor_list(self):
'''
Test that we can GET the monitor list endpoint.
'''
url = reverse('api:v1:monitors:monitor-list')
request = self.factory.get(url)
response = monitor_list(request)
content = get_response_data(response)
assert response.status_code == 200
def test_monitor_detail(self):
monitor = self.get_purple_air()
url = reverse('api:v1:monitors:monitor-detail',
kwargs={'monitor_id': monitor.pk})
request = self.factory.get(url)
request.monitor = monitor
response = monitor_detail(request, monitor_id=monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['data']['id'] == str(monitor.pk)
def test_create_sensor_data(self):
payload = fake_sensor_payload()
url = reverse('api:v1:sensors:sensor-data',
kwargs={'sensor_id': self.sensor.pk})
request = self.factory.post(url, {'payload': payload},
content_type='application/json')
response = sensor_data(request, sensor_id=self.sensor.pk)
assert response.status_code == 200
content = get_response_data(response)
sensor = Sensor.objects.get(pk=self.sensor.pk)
assert content['data']['sensor'] == str(self.sensor.pk)
assert content['data']['id'] == str(sensor.latest_id)
def test_subscription_list_anonymous(self):
'''
Test that we can GET the monitor detail endpoint.
'''
url = reverse('api:v1:subscription-list')
request = self.factory.get(url)
request.monitor = self.monitor
request.user = AnonymousUser()
response = subscription_list(request, monitor_id=self.monitor.pk)
content = get_response_data(response)
assert response.status_code == 403
def test_get_sensor_data(self):
now = timezone.now()
for x in range(10):
data = fake_sensor_data(sensor=self.sensor, save=False)
data.timestamp = now - timedelta(minutes=10 * x)
data.save()
url = reverse('api:v1:sensors:sensor-data',
kwargs={'sensor_id': self.sensor.pk})
request = self.factory.get(url)
response = sensor_data(request, sensor_id=self.sensor.pk)
assert response.status_code == 200
content = get_response_data(response)
assert len(content['data'])
def test_entry_list(self):
monitor = self.get_purple_air()
url = reverse('api:v1:monitors:entry-list',
kwargs={'monitor_id': monitor.pk})
params = {'sensor': 'a', 'field': 'pm2_env'}
request = self.factory.get(url, params)
request.monitor = monitor
response = entry_list(request, monitor_id=monitor.pk)
content = get_response_data(response)
sensor_count = monitor.entries.filter(sensor=params['sensor']).count()
assert response.status_code == 200
assert len(content['data']) == content['count'] == sensor_count
assert set(e['sensor'] for e in content['data']) == {params['sensor']}
def test_subscription_list_authenticated(self):
'''
Test that we can GET the monitor detail endpoint.
'''
Subscription.objects.create(user=self.user,
monitor=self.monitor,
level=Subscription.LEVELS.unhealthy)
url = reverse('api:v1:subscription-list')
request = self.factory.get(url)
request.monitor = self.monitor
request.user = self.user
response = subscription_list(request, monitor_id=self.monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['data'][0]['monitor'] == str(self.monitor.pk)
def test_entry_list_default_sensor(self):
'''
Test that we can GET the entry list endpoint.
'''
monitor = self.get_purple_air()
monitor.default_sensor = 'b'
monitor.save()
url = reverse('api:v1:monitors:entry-list',
kwargs={'monitor_id': monitor.pk})
params = {'field': 'pm2'}
request = self.factory.get(url, params)
request.monitor = monitor
response = entry_list(request, monitor_id=monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert set(e['sensor']
for e in content['data']) == {monitor.default_sensor}
def test_unsubscribe(self):
'''
Test that we can GET the monitor detail endpoint.
'''
Subscription.objects.create(user=self.user,
monitor=self.monitor,
level=Subscription.LEVELS.unhealthy)
url = reverse('api:v1:monitors:alerts:subscribe',
kwargs={'monitor_id': self.monitor.pk})
request = self.factory.post(url)
request.monitor = self.monitor
request.user = self.user
response = unsubscribe(request, monitor_id=self.monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['success'] == True
assert self.user.subscriptions.filter(
monitor_id=self.monitor.pk, ).exists() is False
def test_create_entry(self):
monitor = self.get_bam1022()
payload = {
'timestamp': timezone.now().isoformat(),
'fahrenheit': '92.6',
'pm10_env': '25',
'pm25_env': '30',
'pm100_env': '35',
}
url = reverse('api:v1:monitors:entry-list',
kwargs={'monitor_id': monitor.pk})
request = self.factory.post(url,
payload,
HTTP_ACCESS_KEY=str(monitor.access_key))
request.monitor = monitor
response = entry_list(request, monitor_id=monitor.pk)
content = get_response_data(response)
assert response.status_code == 200
assert content['data']['fahrenheit'] == payload['fahrenheit']
assert content['data']['celcius'] is not None
entry = Entry.objects.latest('timestamp')
assert entry.is_processed
def api_docs(path, json_params=None):
try:
match = resolve(path)
except Resolver404:
return f"Invalid path: {path}"
if json_params is not None:
try:
params = json.loads(json_params)
except Exception:
return str(err)
else:
params = {}
view = getattr(match.func, 'view_class', None)
if not issubclass(view, generics.GenericEndpoint):
return f"View is not an API endpoint: {view}"
middleware = MonitorAccessMiddleware(lambda request: request)
factory = RequestFactory()
request = factory.get(path, params)
middleware.process_view(request, match.func, match.args, match.kwargs)
response = match.func(request, **match.kwargs)
response_data = get_response_data(response)
# Trim the JSON responses
is_json = response.get('Content-Type') == 'application/json'
if (is_json and isinstance(response_data, dict) and 'data' in response_data
and isinstance(response_data['data'], list)):
response_data['data'] = response_data['data'][:1]
# Trim the CSV
is_csv = response.get('Content-Type') == 'text/csv'
if is_csv:
response_data = '\n'.join(response_data.splitlines()[:10])
instance = view()
filters = None
if hasattr(instance, 'get_filter_class'):
filter_class = instance.get_filter_class()
if filter_class is not None:
filters = [(k, f.__class__.__name__)
for k, f in filter_class.get_filters().items()]
context = {
'name':
match.url_name,
'route':
f"/{match.route.lstrip('/')}",
'filters':
filters,
'is_json':
is_json,
'is_csv':
is_csv,
'is_download':
response.get('Content-Disposition', '').startswith('attachment'),
'data':
response_data,
}
return render_to_string('api/endpoint-get.html', context)
def test_monitor_list(self):
url = reverse('api:v1:monitors:monitor-list')
request = self.factory.get(url)
response = monitor_list(request)
content = get_response_data(response)
assert response.status_code == 200