diff --git a/.travis.yml b/.travis.yml index a807c73..defeb3e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,20 +1,18 @@ language: python python: - - 2.7 - - 3.3 - - 3.4 + - "3.5" + - "3.6" install: # install deps - pip install -r requirements.txt + - pip install pytest-cov mock assertpy python-coveralls - pip install fastcluster - - pip install twisted - - pip install python-coveralls - pip list script: - - nosetests + - py.test after_success: - coveralls diff --git a/blitzortung/__init__.py b/blitzortung/__init__.py index fb4da53..be977a9 100644 --- a/blitzortung/__init__.py +++ b/blitzortung/__init__.py @@ -53,7 +53,7 @@ class Error(Exception): from . import db INJECTOR = injector.Injector( - [config.ConfigModule(), db.DbModule()]) + [config.ConfigModule(), db.DbModule()]) __all__ = [ diff --git a/blitzortung/builder/__init__.py b/blitzortung/builder/__init__.py index 8ae2569..8f44895 100644 --- a/blitzortung/builder/__init__.py +++ b/blitzortung/builder/__init__.py @@ -1,4 +1,4 @@ from .base import Timestamp, Event, BuilderError -from .strike import Strike -from .station import Station, StationOffline from .raw_signal import RawWaveformEvent, ChannelWaveform +from .station import Station, StationOffline +from .strike import Strike diff --git a/blitzortung/builder/raw_signal.py b/blitzortung/builder/raw_signal.py index fe4dd3b..6276b65 100644 --- a/blitzortung/builder/raw_signal.py +++ b/blitzortung/builder/raw_signal.py @@ -19,12 +19,12 @@ """ import itertools -import datetime + from injector import inject -from ..util import next_element from .base import Event, BuilderError from .. import data +from ..util import next_element class ChannelWaveform(object): @@ -94,8 +94,8 @@ class RawWaveformEvent(Event): class for building of raw signal objects """ - @inject(channel_builder=ChannelWaveform) - def __init__(self, channel_builder): + @inject + def __init__(self, channel_builder: ChannelWaveform): super(RawWaveformEvent, self).__init__() self.altitude = 0 self.channels = [] diff --git a/blitzortung/builder/strike.py b/blitzortung/builder/strike.py index 8d97772..a5ffff4 100644 --- a/blitzortung/builder/strike.py +++ b/blitzortung/builder/strike.py @@ -19,9 +19,10 @@ """ import re + from .base import Event, BuilderError -from ..util import force_range from .. import data +from ..util import force_range class Strike(Event): diff --git a/blitzortung/cache.py b/blitzortung/cache.py index aab4ec6..e030971 100644 --- a/blitzortung/cache.py +++ b/blitzortung/cache.py @@ -19,6 +19,7 @@ """ from __future__ import division + import time diff --git a/blitzortung/config.py b/blitzortung/config.py index 40e39a9..6622401 100644 --- a/blitzortung/config.py +++ b/blitzortung/config.py @@ -18,20 +18,18 @@ """ -from __future__ import unicode_literals - try: import configparser except ImportError: import ConfigParser as configparser -from injector import Module, singleton, provides, inject +from injector import Module, singleton, inject, provider @singleton class Config(object): - @inject(config_parser=configparser.ConfigParser) - def __init__(self, config_parser): + @inject + def __init__(self, config_parser: configparser.ConfigParser): self.config_parser = config_parser def get_username(self): @@ -69,8 +67,8 @@ def config(): class ConfigModule(Module): @singleton - @provides(configparser.ConfigParser) - def provide_config_parser(self): + @provider + def provide_config_parser(self) -> configparser.ConfigParser: config_parser = configparser.ConfigParser() config_parser.read('/etc/blitzortung.conf') return config_parser diff --git a/blitzortung/data.py b/blitzortung/data.py index 607ca8d..9c66b7c 100644 --- a/blitzortung/data.py +++ b/blitzortung/data.py @@ -18,16 +18,14 @@ """ -from __future__ import unicode_literals, generators - import datetime +import math import pytz import six -from . import types -import math from blitzortung.geom import GridElement +from . import types class Timestamp(types.EqualityAndHash): @@ -37,7 +35,7 @@ class Timestamp(types.EqualityAndHash): __slots__ = ['datetime', 'nanosecond'] def __init__(self, date_time=datetime.datetime.utcnow().replace(tzinfo=pytz.UTC), nanosecond=0): - if type(date_time) == str or type(date_time) == unicode: + if type(date_time) == str: date_time, date_time_nanosecond = Timestamp.from_timestamp(date_time) nanosecond += date_time_nanosecond elif type(date_time) == int: @@ -45,7 +43,7 @@ def __init__(self, date_time=datetime.datetime.utcnow().replace(tzinfo=pytz.UTC) nanosecond += date_time_nanosecond if nanosecond < 0 or nanosecond > 999: - microdelta = nanosecond / 1000 + microdelta = nanosecond // 1000 date_time += datetime.timedelta(microseconds=microdelta) nanosecond -= microdelta * 1000 @@ -71,13 +69,13 @@ def from_timestamp(timestamp_string): @staticmethod def from_nanoseconds(total_nanoseconds): - total_microseconds = total_nanoseconds / 1000 + total_microseconds = total_nanoseconds // 1000 residual_nanoseconds = total_nanoseconds % 1000 - total_seconds = total_microseconds / 1000000 + total_seconds = total_microseconds // 1000000 residual_microseconds = total_microseconds % 1000000 return datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC) + \ datetime.timedelta(seconds=total_seconds, - milliseconds=residual_microseconds), \ + microseconds=residual_microseconds), \ residual_nanoseconds @property @@ -130,25 +128,29 @@ def __lt__(self, other): if type(other) == datetime.datetime: return self.datetime < other else: - return self.datetime < other.datetime or (self.datetime == other.datetime and self.nanosecond < other.nanosecond) + return self.datetime < other.datetime or ( + self.datetime == other.datetime and self.nanosecond < other.nanosecond) def __le__(self, other): if type(other) == datetime.datetime: return self.datetime <= other else: - return self.datetime < other.datetime or (self.datetime == other.datetime and self.nanosecond <= other.nanosecond) + return self.datetime < other.datetime or ( + self.datetime == other.datetime and self.nanosecond <= other.nanosecond) def __gt__(self, other): if type(other) == datetime.datetime: return self.datetime > other else: - return self.datetime > other.datetime or (self.datetime == other.datetime and self.nanosecond > other.nanosecond) + return self.datetime > other.datetime or ( + self.datetime == other.datetime and self.nanosecond > other.nanosecond) def __ge__(self, other): if type(other) == datetime.datetime: return self.datetime >= other else: - return self.datetime > other.datetime or (self.datetime == other.datetime and self.nanosecond >= other.nanosecond) + return self.datetime > other.datetime or ( + self.datetime == other.datetime and self.nanosecond >= other.nanosecond) def __add__(self, other): if type(other) == Timedelta: @@ -188,7 +190,7 @@ def __repr__(self): class Timedelta(types.EqualityAndHash): def __init__(self, timedelta=datetime.timedelta(), nanodelta=0): if nanodelta < 0 or nanodelta > 999: - microdelta = nanodelta / 1000 + microdelta = nanodelta // 1000 timedelta += datetime.timedelta(microseconds=microdelta) nanodelta -= microdelta * 1000 self.timedelta = timedelta @@ -298,7 +300,8 @@ def __str__(self): offline_since = self.timestamp status_char = "*" if offline_since is None else "-" try: - status_text = "" if offline_since is None else " offline since " + offline_since.strftime("%Y-%m-%d %H:%M %Z") + status_text = "" if offline_since is None else " offline since " + offline_since.strftime( + "%Y-%m-%d %H:%M %Z") except ValueError: status_text = 'n/a' return u"%s%3d/%3d '%s' '%s' (%.4f, %.4f)%s" % ( diff --git a/blitzortung/dataimport/base.py b/blitzortung/dataimport/base.py index c6e52c3..3c0aee8 100644 --- a/blitzortung/dataimport/base.py +++ b/blitzortung/dataimport/base.py @@ -18,11 +18,10 @@ """ -from abc import abstractmethod - -import os -import logging import datetime +import logging +import os +from abc import abstractmethod try: from html.parser import HTMLParser @@ -60,8 +59,8 @@ class HttpFileTransport(FileTransport): logger = logging.getLogger(__name__) html_parser = HTMLParser() - @inject(configuration=config.Config) - def __init__(self, configuration, session=None): + @inject + def __init__(self, configuration: config.Config, session=None): self.config = configuration self.session = session if session else Session() diff --git a/blitzortung/dataimport/raw_signal.py b/blitzortung/dataimport/raw_signal.py index 12f8f0b..ced5ec3 100644 --- a/blitzortung/dataimport/raw_signal.py +++ b/blitzortung/dataimport/raw_signal.py @@ -31,9 +31,9 @@ class RawSignalsBlitzortungDataProvider(object): logger = logging.getLogger(__name__) - @inject(data_transport=HttpFileTransport, data_url=BlitzortungDataPath, - url_path_generator=BlitzortungDataPathGenerator, waveform_builder=builder.RawWaveformEvent) - def __init__(self, data_transport, data_url, url_path_generator, waveform_builder): + @inject + def __init__(self, data_transport: HttpFileTransport, data_url: BlitzortungDataPath, + url_path_generator: BlitzortungDataPathGenerator, waveform_builder: builder.RawWaveformEvent): self.data_transport = data_transport self.data_url = data_url self.url_path_generator = url_path_generator diff --git a/blitzortung/dataimport/station.py b/blitzortung/dataimport/station.py index fd86378..de778d7 100644 --- a/blitzortung/dataimport/station.py +++ b/blitzortung/dataimport/station.py @@ -27,13 +27,14 @@ from .base import HttpFileTransport, BlitzortungDataPath from .. import builder + @singleton class StationsBlitzortungDataProvider(object): logger = logging.getLogger(__name__) - @inject(data_transport=HttpFileTransport, data_url=BlitzortungDataPath, - station_builder=builder.Station) - def __init__(self, data_transport, data_url, station_builder): + @inject + def __init__(self, data_transport: HttpFileTransport, data_url: BlitzortungDataPath, + station_builder: builder.Station): self.data_transport = data_transport self.data_url = data_url self.station_builder = station_builder diff --git a/blitzortung/dataimport/strike.py b/blitzortung/dataimport/strike.py index a3b97eb..9c1a158 100644 --- a/blitzortung/dataimport/strike.py +++ b/blitzortung/dataimport/strike.py @@ -18,24 +18,25 @@ """ +import datetime import logging import os import time -import pytz -import datetime +import pytz from injector import singleton, inject from .base import HttpFileTransport, BlitzortungDataPath, BlitzortungDataPathGenerator from .. import builder + @singleton class StrikesBlitzortungDataProvider(object): logger = logging.getLogger(__name__) - @inject(data_transport=HttpFileTransport, data_url=BlitzortungDataPath, - url_path_generator=BlitzortungDataPathGenerator, strike_builder=builder.Strike) - def __init__(self, data_transport, data_url, url_path_generator, strike_builder): + @inject + def __init__(self, data_transport: HttpFileTransport, data_url: BlitzortungDataPath, + url_path_generator: BlitzortungDataPathGenerator, strike_builder: builder.Strike): self.data_transport = data_transport self.data_url = data_url self.url_path_generator = url_path_generator diff --git a/blitzortung/db/__init__.py b/blitzortung/db/__init__.py index db18595..9b9d731 100644 --- a/blitzortung/db/__init__.py +++ b/blitzortung/db/__init__.py @@ -18,9 +18,10 @@ """ -from injector import Module, provides, singleton, inject import atexit +from injector import Module, singleton, inject, provider + def create_psycopg2_dummy(): class Dummy(object): @@ -51,9 +52,9 @@ def cleanup(connection_pool): connection_pool.closeall() @singleton - @provides(psycopg2.pool.ThreadedConnectionPool) - @inject(config=config.Config) - def provide_psycopg2_connection_pool(self, config): + @provider + @inject + def provide_psycopg2_connection_pool(self, config: config.Config) -> psycopg2.pool.ThreadedConnectionPool: connection_pool = psycopg2.pool.ThreadedConnectionPool(4, 50, config.get_db_connection_string()) atexit.register(self.cleanup, connection_pool) return connection_pool diff --git a/blitzortung/db/mapper.py b/blitzortung/db/mapper.py index 92e97dc..d28c2d9 100644 --- a/blitzortung/db/mapper.py +++ b/blitzortung/db/mapper.py @@ -19,9 +19,10 @@ """ from abc import abstractmethod -from injector import inject + import pytz import shapely.wkb +from injector import inject import blitzortung.builder @@ -42,8 +43,8 @@ def convert_to_timezone(timestamp, target_timezone=None): class Strike(ObjectMapper): - @inject(strike_builder=blitzortung.builder.Strike) - def __init__(self, strike_builder): + @inject + def __init__(self, strike_builder: blitzortung.builder.Strike): self.strike_builder = strike_builder def create_object(self, result, **kwargs): @@ -64,8 +65,8 @@ def create_object(self, result, **kwargs): class Station(ObjectMapper): - @inject(station_builder=blitzortung.builder.Station) - def __init__(self, station_builder): + @inject + def __init__(self, station_builder: blitzortung.builder.Station): self.station_builder = station_builder def create_object(self, result, **kwargs): @@ -85,8 +86,8 @@ def create_object(self, result, **kwargs): class StationOffline(ObjectMapper): - @inject(station_offline_builder=blitzortung.builder.StationOffline) - def __init__(self, station_offline_builder): + @inject + def __init__(self, station_offline_builder: blitzortung.builder.StationOffline): self.station_offline_builder = station_offline_builder def create_object(self, result, **kwargs): diff --git a/blitzortung/db/query.py b/blitzortung/db/query.py index 57415ca..9a3c115 100644 --- a/blitzortung/db/query.py +++ b/blitzortung/db/query.py @@ -21,6 +21,7 @@ from __future__ import print_function import datetime + import shapely.geometry.base import shapely.wkb @@ -203,9 +204,9 @@ def add_geometry(self, geometry): if not geometry.equals(geometry.envelope): self.add_condition( - 'ST_Intersects(ST_GeomFromWKB(%(geometry)s, %(srid)s), ' + - 'ST_Transform(geog::geometry, %(srid)s))', - geometry=psycopg2.Binary(shapely.wkb.dumps(geometry))) + 'ST_Intersects(ST_GeomFromWKB(%(geometry)s, %(srid)s), ' + + 'ST_Transform(geog::geometry, %(srid)s))', + geometry=psycopg2.Binary(shapely.wkb.dumps(geometry))) else: raise ValueError("invalid geometry in db.Strike.select()") @@ -253,18 +254,18 @@ def __init__(self, raster, count_threshold=0): self.raster = raster self.add_parameters( - srid=raster.srid, - xmin=raster.x_min, - xdiv=raster.x_div, - ymin=raster.y_min, - ydiv=raster.y_div, + srid=raster.srid, + xmin=raster.x_min, + xdiv=raster.x_div, + ymin=raster.y_min, + ydiv=raster.y_div, ) self.set_columns( - 'TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx', - 'TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry', - 'count(*) AS strike_count', - 'max("timestamp") as "timestamp"' + 'TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx', + 'TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry', + 'count(*) AS strike_count', + 'max("timestamp") as "timestamp"' ) env = self.raster.env diff --git a/blitzortung/db/table.py b/blitzortung/db/table.py index 1e0d9df..058d262 100644 --- a/blitzortung/db/table.py +++ b/blitzortung/db/table.py @@ -19,21 +19,19 @@ """ from __future__ import print_function -import logging +import logging import math -from injector import inject import pytz -import shapely.wkb - -from .. import data -from .. import geom +from injector import inject -from . import query +from blitzortung.logger import get_logger_name from . import mapper +from . import query from . import query_builder -from blitzortung.logger import get_logger_name +from .. import data +from .. import geom try: import psycopg2 @@ -232,9 +230,9 @@ class Strike(Base): TABLE_NAME = 'strikes' - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool, query_builder_=query_builder.Strike, - strike_mapper=mapper.Strike) - def __init__(self, db_connection_pool, query_builder_, strike_mapper): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool, query_builder_: query_builder.Strike, + strike_mapper: mapper.Strike): super(Strike, self).__init__(db_connection_pool) self.query_builder = query_builder_ @@ -278,7 +276,8 @@ def select(self, **kwargs): query_ = self.query_builder.select_query(self.full_table_name, self.srid, **kwargs) - return self.execute_many(str(query_), query_.get_parameters(), self.strike_mapper.create_object, timezone=self.tz) + return self.execute_many(str(query_), query_.get_parameters(), self.strike_mapper.create_object, + timezone=self.tz) def select_grid(self, grid, count_threshold, **kwargs): """ build up raster query """ @@ -338,8 +337,8 @@ class Station(Base): ALTER SEQUENCE stations_id_seq RESTART 1; """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool, station_mapper=mapper.Station) - def __init__(self, db_connection_pool, station_mapper): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool, station_mapper: mapper.Station): super(Station, self).__init__(db_connection_pool) self.table_name = 'stations' @@ -394,9 +393,9 @@ class StationOffline(Base): ALTER SEQUENCE stations_offline_id_seq RESTART 1; """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool, - station_offline_mapper=mapper.StationOffline) - def __init__(self, db_connection_pool, station_offline_mapper): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool, + station_offline_mapper: mapper.StationOffline): super(StationOffline, self).__init__(db_connection_pool) self.table_name = 'stations_offline' @@ -441,8 +440,8 @@ class Location(Base): """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool) - def __init__(self, db_connection_pool): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool): super(Location, self).__init__(db_connection_pool) self.schema_name = 'geo' self.table_name = 'geonames' @@ -588,8 +587,8 @@ class ServiceLogTotal(ServiceLogBase): CREATE INDEX servicelog_total_timestamp ON servicelog_total USING btree("timestamp"); """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool) - def __init__(self, db_connection_pool): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool): super(ServiceLogTotal, self).__init__(db_connection_pool) self.table_name = 'servicelog_total' @@ -614,8 +613,8 @@ class ServiceLogCountry(ServiceLogBase): CREATE INDEX servicelog_country_timestamp ON servicelog_country USING btree("timestamp"); """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool) - def __init__(self, db_connection_pool): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool): super(ServiceLogCountry, self).__init__(db_connection_pool) self.table_name = 'servicelog_country' @@ -641,8 +640,8 @@ class ServiceLogVersion(ServiceLogBase): CREATE INDEX servicelog_version_timestamp ON servicelog_version USING btree("timestamp"); """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool) - def __init__(self, db_connection_pool): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool): super(ServiceLogVersion, self).__init__(db_connection_pool) self.table_name = 'servicelog_version' @@ -668,8 +667,8 @@ class ServiceLogParameters(ServiceLogBase): CREATE INDEX servicelog_parameters_timestamp ON servicelog_parameters USING btree("timestamp"); """ - @inject(db_connection_pool=psycopg2.pool.ThreadedConnectionPool) - def __init__(self, db_connection_pool): + @inject + def __init__(self, db_connection_pool: psycopg2.pool.ThreadedConnectionPool): super(ServiceLogParameters, self).__init__(db_connection_pool) self.table_name = 'servicelog_parameters' diff --git a/blitzortung/files.py b/blitzortung/files.py index 1734821..4d00e2b 100644 --- a/blitzortung/files.py +++ b/blitzortung/files.py @@ -19,15 +19,17 @@ """ from __future__ import print_function -import os -import subprocess -import glob + import datetime +import glob import json +import os +import subprocess + import pandas as pd -import blitzortung.builder import blitzortung +import blitzortung.builder class Raw(object): diff --git a/blitzortung/geom.py b/blitzortung/geom.py index 36b37ad..01f131e 100644 --- a/blitzortung/geom.py +++ b/blitzortung/geom.py @@ -20,8 +20,8 @@ import math from abc import ABCMeta, abstractmethod -import pyproj +import pyproj import shapely.geometry @@ -82,8 +82,8 @@ def contains(self, point): @property def env(self): return shapely.geometry.LinearRing( - [(self.x_min, self.y_min), (self.x_min, self.y_max), (self.x_max, self.y_max), - (self.x_max, self.y_min)]) + [(self.x_min, self.y_min), (self.x_min, self.y_max), (self.x_max, self.y_max), + (self.x_max, self.y_min)]) def __repr__(self): return 'Envelope(x: %.4f..%.4f, y: %.4f..%.4f)' % ( diff --git a/blitzortung/logger.py b/blitzortung/logger.py index 1a1ec5b..7408fab 100644 --- a/blitzortung/logger.py +++ b/blitzortung/logger.py @@ -29,4 +29,4 @@ def create_console_handler(): def get_logger_name(clazz): - return "{}.{}".format(clazz.__module__, clazz.__name__) \ No newline at end of file + return "{}.{}".format(clazz.__module__, clazz.__name__) diff --git a/blitzortung/service/general.py b/blitzortung/service/general.py index 9612437..f94c464 100644 --- a/blitzortung/service/general.py +++ b/blitzortung/service/general.py @@ -18,9 +18,11 @@ """ -import time import datetime +import time + import pytz + import blitzortung @@ -34,7 +36,6 @@ def create_time_interval(minute_length, minute_offset): class TimingState(object): - __slots__ = ['statsd_client', 'reference_time', 'name', 'info_text'] def __init__(self, name, statsd_client): diff --git a/blitzortung/service/histogram.py b/blitzortung/service/histogram.py index 9d60465..b477eb8 100644 --- a/blitzortung/service/histogram.py +++ b/blitzortung/service/histogram.py @@ -18,8 +18,10 @@ """ -from injector import inject import time + +from injector import inject + import blitzortung.db.query_builder diff --git a/blitzortung/service/strike.py b/blitzortung/service/strike.py index f34b27c..dfc309b 100644 --- a/blitzortung/service/strike.py +++ b/blitzortung/service/strike.py @@ -21,16 +21,16 @@ from __future__ import print_function import time + from injector import inject from twisted.internet.defer import gatherResults from twisted.python import log -from .. import db, geom from .general import TimingState, create_time_interval +from .. import db, geom class StrikeState(TimingState): - __slots__ = ['end_time'] def __init__(self, statsd_client, end_time): @@ -51,7 +51,8 @@ def create(self, id_or_offset, minute_length, minute_offset, connection, statsd_ id_interval = db.query.IdInterval(id_or_offset) if id_or_offset > 0 else None order = db.query.Order('id') query = self.strike_query_builder.select_query(db.table.Strike.TABLE_NAME, geom.Geometry.DefaultSrid, - time_interval=time_interval, order=order, id_interval=id_interval) + time_interval=time_interval, order=order, + id_interval=id_interval) strikes_result = connection.runQuery(str(query), query.get_parameters()) strikes_result.addCallback(self.strike_build_results, state=state) diff --git a/blitzortung/service/strike_grid.py b/blitzortung/service/strike_grid.py index f3ee647..2223569 100644 --- a/blitzortung/service/strike_grid.py +++ b/blitzortung/service/strike_grid.py @@ -18,14 +18,14 @@ """ -from injector import inject import time + +from injector import inject from twisted.internet.defer import gatherResults from twisted.python import log -from .. import db - from .general import create_time_interval, TimingState +from .. import db class StrikeGridState(TimingState): @@ -65,12 +65,12 @@ def build_strikes_grid_result(results, state): y_bin_count = state.grid_parameters.y_bin_count end_time = state.time_interval.end strikes_grid_result = tuple( - ( - result['rx'], - y_bin_count - result['ry'], - result['strike_count'], - -(end_time - result['timestamp']).seconds - ) for result in results if 0 <= result['rx'] < x_bin_count and 0 < result['ry'] <= y_bin_count + ( + result['rx'], + y_bin_count - result['ry'], + result['strike_count'], + -(end_time - result['timestamp']).seconds + ) for result in results if 0 <= result['rx'] < x_bin_count and 0 < result['ry'] <= y_bin_count ) state.add_info_text(", result %.03fs" % state.get_seconds(reference_time)) state.log_timing('strikes_grid.build_result', reference_time) diff --git a/blitzortung/types.py b/blitzortung/types.py index 891b0fe..ef341d0 100644 --- a/blitzortung/types.py +++ b/blitzortung/types.py @@ -19,6 +19,7 @@ """ import math + import pyproj diff --git a/blitzortung/util.py b/blitzortung/util.py index 4100e10..f89628c 100644 --- a/blitzortung/util.py +++ b/blitzortung/util.py @@ -18,10 +18,10 @@ """ -import sys - import datetime +import sys import time + import pytz from blitzortung.data import Timestamp @@ -72,7 +72,8 @@ def round_time(time_value, duration): """ duration_seconds = total_seconds(duration) seconds = (total_seconds(time_value) // duration_seconds) * duration_seconds - time_value.nanosecond = 0 + if isinstance(time_value, Timestamp): + time_value.nanosecond = 0 return time_value.replace( hour=seconds // 3600, minute=seconds // 60 % 60, @@ -91,7 +92,6 @@ def time_intervals(start_time, duration, end_time=None): if not end_time: end_time = datetime.datetime.utcnow() end_time = end_time.replace(tzinfo=pytz.UTC) - end_time = Timestamp(end_time) end_time = round_time(end_time, duration) while current_time <= end_time: @@ -102,4 +102,5 @@ def time_intervals(start_time, duration, end_time=None): def force_range(lower_limit, value, upper_limit): return lower_limit if value < lower_limit else upper_limit if value > upper_limit else value + next_element = (lambda iterator: iterator.next()) if sys.version < '3' else (lambda iterator: next(iterator)) diff --git a/requirements.txt b/requirements.txt index 76390b6..1972a52 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,15 +1,10 @@ -nose>=1.3.1 -mock>=1.0.1 -coverage>=3.7.1 -cython>=0.19.0 -PyHamcrest>=1.8.0 -assertpy>=0.8.0 +cython>=0.26.1 injector>=0.8.0 -lockfile>=0.9.1 -requests>=2.2.1 -pytz>=2014.2 -psycopg2>=2.5.2 -pyproj>=1.9.3 -Shapely>=1.3.0 -statsd>=2.1.2 -six>=1.9.0 +lockfile==0.12.2 +requests==2.18.4 +pytz==2018.3 +psycopg2==2.8.3 +pyproj>=1.9.5.1 +Shapely==1.6.4 +statsd==3.2.1 +twisted==17.9.0 \ No newline at end of file diff --git a/tests/db/test_db_mapper.py b/tests/db/test_db_mapper.py index abb4d17..55369fb 100644 --- a/tests/db/test_db_mapper.py +++ b/tests/db/test_db_mapper.py @@ -18,14 +18,14 @@ """ -from unittest import TestCase import datetime +from unittest import TestCase import pytz -from mock import Mock, call -from hamcrest import assert_that, is_, equal_to, none -import shapely.wkb import shapely.geometry +import shapely.wkb +from assertpy import assert_that +from mock import Mock, call import blitzortung.builder import blitzortung.db.mapper @@ -52,9 +52,9 @@ def setUp(self): self.strike_builder.build.return_value = self.strike def test_strike_mapper(self): - assert_that(self.strike_mapper.create_object(self.result), is_(self.strike)) + assert_that(self.strike_mapper.create_object(self.result)).is_equal_to(self.strike) - assert_that(self.strike_builder.method_calls, is_([ + assert_that(self.strike_builder.method_calls).is_equal_to([ call.set_id(12), call.set_timestamp(self.timestamp, 789), call.set_x(11.0), @@ -64,7 +64,7 @@ def test_strike_mapper(self): call.set_station_count(12), call.set_lateral_error(5000), call.build() - ])) + ]) def test_strike_mapper_with_timezone(self): zone = pytz.timezone('CET') @@ -73,15 +73,15 @@ def test_strike_mapper_with_timezone(self): timestamp = self.strike_builder.set_timestamp.call_args[0][0] - assert_that(timestamp, is_(self.timestamp)) - assert_that(timestamp.tzinfo.zone, is_(zone.zone)) + assert_that(timestamp).is_equal_to(self.timestamp) + assert_that(timestamp.tzinfo.zone).is_equal_to(zone.zone) def test_strike_mapper_without_timestamp(self): self.result['timestamp'] = None self.strike_mapper.create_object(self.result) - assert_that(self.strike_builder.set_timestamp.call_args[0][0], is_(none())) + assert_that(self.strike_builder.set_timestamp.call_args[0][0]).is_none() class TestStationMapper(TestCase): @@ -103,9 +103,9 @@ def setUp(self): self.station_builder.build.return_value = self.station def test_station_mapper(self): - assert_that(self.strike_mapper.create_object(self.result), is_(self.station)) + assert_that(self.strike_mapper.create_object(self.result)).is_equal_to(self.station) - assert_that(self.station_builder.method_calls, is_([ + assert_that(self.station_builder.method_calls).is_equal_to([ call.set_number(31), call.set_user(''), call.set_name(''), @@ -114,7 +114,7 @@ def test_station_mapper(self): call.set_y(49.0), call.set_timestamp(self.timestamp), call.build() - ])) + ]) def test_strike_mapper_with_timezone(self): zone = pytz.timezone('CET') @@ -123,12 +123,12 @@ def test_strike_mapper_with_timezone(self): timestamp = self.station_builder.set_timestamp.call_args[0][0] - assert_that(timestamp, is_(self.timestamp)) - assert_that(timestamp.tzinfo.zone, is_(zone.zone)) + assert_that(timestamp).is_equal_to(self.timestamp) + assert_that(timestamp.tzinfo.zone).is_equal_to(zone.zone) def test_strike_mapper_without_timestamp(self): self.result['begin'] = None self.strike_mapper.create_object(self.result) - assert_that(self.station_builder.set_timestamp.call_args[0][0], is_(none())) + assert_that(self.station_builder.set_timestamp.call_args[0][0]).is_none() diff --git a/tests/db/test_db_query.py b/tests/db/test_db_query.py index e1b2d20..a12a13a 100644 --- a/tests/db/test_db_query.py +++ b/tests/db/test_db_query.py @@ -18,11 +18,12 @@ """ -from unittest import TestCase import datetime -from hamcrest import assert_that, is_, equal_to -from nose.tools import raises +from unittest import TestCase + +import pytest import shapely.wkb +from assertpy import assert_that import blitzortung import blitzortung.db.query @@ -50,13 +51,13 @@ def test_start_and_stop_set(self): self.assertEqual(id_interval.end, 5678) self.assertEqual(str(id_interval), "[1234 : 5678]") - @raises(ValueError) def test_exception_when_start_is_not_integer(self): - blitzortung.db.query.IdInterval("asdf") + with pytest.raises(ValueError): + blitzortung.db.query.IdInterval("asdf") - @raises(ValueError) def test_exception_when_end_is_not_integer(self): - blitzortung.db.query.IdInterval(1, "asdf") + with pytest.raises(ValueError): + blitzortung.db.query.IdInterval(1, "asdf") class TimeIntervalTest(TestCase): @@ -88,13 +89,13 @@ def test_get_duration(self): self.assertEqual(id_interval.duration, datetime.timedelta(minutes=10)) - @raises(ValueError) def test_exception_when_start_is_not_integer(self): - blitzortung.db.query.TimeInterval("asdf") + with pytest.raises(ValueError): + blitzortung.db.query.TimeInterval("asdf") - @raises(ValueError) def test_exception_when_end_is_not_integer(self): - blitzortung.db.query.TimeInterval(datetime.datetime.utcnow(), "asdf") + with pytest.raises(ValueError): + blitzortung.db.query.TimeInterval(datetime.datetime.utcnow(), "asdf") class QueryTest(TestCase): @@ -130,12 +131,12 @@ def test_add_condition(self): def test_add_condition_with_parameters(self): self.query.add_condition("column LIKE %(name)s", name='') - assert_that(str(self.query), is_(equal_to("WHERE column LIKE %(name)s"))) - assert_that(self.query.get_parameters(), is_(equal_to({'name': ''}))) + assert_that(str(self.query)).is_equal_to("WHERE column LIKE %(name)s") + assert_that(self.query.get_parameters()).is_equal_to({'name': ''}) self.query.add_condition("other LIKE %(type)s", type='') - assert_that(str(self.query), is_(equal_to("WHERE column LIKE %(name)s AND other LIKE %(type)s"))) - assert_that(self.query.get_parameters(), is_(equal_to({'name': '', 'type': ''}))) + assert_that(str(self.query)).is_equal_to("WHERE column LIKE %(name)s AND other LIKE %(type)s") + assert_that(self.query.get_parameters()).is_equal_to({'name': '', 'type': ''}) def test_add_order(self): self.query.set_order(blitzortung.db.query.Order("bar")) @@ -156,34 +157,34 @@ def test_set_limit(self): def test_parse_args_with_id_interval(self): self.query.set_default_conditions(id_interval=blitzortung.db.query.IdInterval(10, 15)) - assert_that(str(self.query), is_(equal_to("WHERE id >= %(start_id)s AND id < %(end_id)s"))) - assert_that(self.query.get_parameters(), is_(equal_to({'start_id': 10, 'end_id': 15}))) + assert_that(str(self.query)).is_equal_to("WHERE id >= %(start_id)s AND id < %(end_id)s") + assert_that(self.query.get_parameters()).is_equal_to({'start_id': 10, 'end_id': 15}) def test_parse_args_with_time_interval(self): self.query.set_default_conditions(time_interval=blitzortung.db.query.TimeInterval( datetime.datetime(2013, 10, 9, 17, 20), datetime.datetime(2013, 10, 11, 6, 30))) - assert_that(str(self.query), is_(equal_to( + assert_that(str(self.query)).is_equal_to( "WHERE \"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s" - ))) - assert_that(self.query.get_parameters(), is_(equal_to({ + ) + assert_that(self.query.get_parameters()).is_equal_to({ 'start_time': datetime.datetime(2013, 10, 9, 17, 20), - 'end_time': datetime.datetime(2013, 10, 11, 6, 30)}))) + 'end_time': datetime.datetime(2013, 10, 11, 6, 30)}) def test_parse_args_with_order(self): self.query.set_default_conditions(order='test') - assert_that(str(self.query), is_(equal_to( + assert_that(str(self.query)).is_equal_to( "ORDER BY test" - ))) + ) def test_parse_args_with_limit(self): self.query.set_default_conditions(limit=10) - assert_that(str(self.query), is_(equal_to( + assert_that(str(self.query)).is_equal_to( "LIMIT 10" - ))) + ) class SelectQueryTest(TestCase): @@ -215,11 +216,11 @@ def test_add_condition(self): self.assertEqual(str(self.query), "SELECT FROM foo WHERE qux AND quux") def test_add_parameters(self): - assert_that(self.query.get_parameters(), is_(equal_to({}))) + assert_that(self.query.get_parameters()).is_equal_to({}) self.query.add_parameters(foo='bar', baz='qux') - assert_that(self.query.get_parameters(), is_(equal_to({'foo': 'bar', 'baz': 'qux'}))) + assert_that(self.query.get_parameters()).is_equal_to({'foo': 'bar', 'baz': 'qux'}) class GridQueryTest(TestCase): @@ -229,7 +230,7 @@ def test_with_raster(self): query = blitzortung.db.query.GridQuery(raster) query.set_table_name('strikes') - assert_that(str(query), is_(equal_to( + assert_that(str(query)).is_equal_to( 'SELECT ' 'TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx, ' 'TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry, ' @@ -237,15 +238,14 @@ def test_with_raster(self): 'max("timestamp") as "timestamp" ' 'FROM strikes ' 'WHERE ST_GeomFromWKB(%(envelope)s, %(envelope_srid)s) && geog ' - 'GROUP BY rx, ry'))) + 'GROUP BY rx, ry') parameters = query.get_parameters() - assert_that(parameters['xmin'], is_(equal_to(-10))) - assert_that(parameters['xdiv'], is_(equal_to(1.5))) - assert_that(parameters['ymin'], is_(equal_to(15))) - assert_that(parameters['ydiv'], is_(equal_to(1))) - assert_that(parameters['srid'], is_(equal_to(4326))) - assert_that(parameters['envelope_srid'], is_(equal_to(4326))) + assert_that(parameters['xmin']).is_equal_to(-10) + assert_that(parameters['xdiv']).is_equal_to(1.5) + assert_that(parameters['ymin']).is_equal_to(15) + assert_that(parameters['ydiv']).is_equal_to(1) + assert_that(parameters['srid']).is_equal_to(4326) + assert_that(parameters['envelope_srid']).is_equal_to(4326) envelope = shapely.wkb.loads(parameters['envelope'].adapted) - assert_that(envelope.bounds, is_(equal_to((-10, 15, 20, 35)))) - + assert_that(envelope.bounds).is_equal_to((-10, 15, 20, 35)) diff --git a/tests/db/test_db_query_builder.py b/tests/db/test_db_query_builder.py index 5bab3cd..c87e5fb 100644 --- a/tests/db/test_db_query_builder.py +++ b/tests/db/test_db_query_builder.py @@ -18,19 +18,18 @@ """ -import unittest import datetime -from hamcrest import assert_that, is_, equal_to, contains, contains_inanyorder, not_none -from nose.tools import raises + import pytz +from assertpy import assert_that import blitzortung -from blitzortung.db.query import TimeInterval import blitzortung.db.query_builder +from blitzortung.db.query import TimeInterval from blitzortung.geom import Grid -class StrikeTest(unittest.TestCase): +class StrikeTest(object): def setUp(self): self.query_builder = blitzortung.db.query_builder.Strike() self.end_time = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC, second=0, microsecond=0) @@ -41,41 +40,40 @@ def test_select_query(self): query = self.query_builder.select_query("", self.srid, time_interval=TimeInterval(self.start_time, self.end_time)) - assert_that(str(query), - is_("SELECT id, \"timestamp\", nanoseconds, ST_X(ST_Transform(geog::geometry, %(srid)s))" - " AS x, ST_Y(ST_Transform(geog::geometry, %(srid)s)) AS y, altitude, amplitude, error2d, stationcount " - "FROM WHERE \"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s")) + assert_that(str(query)).is_equal_to( + "SELECT id, \"timestamp\", nanoseconds, ST_X(ST_Transform(geog::geometry, %(srid)s))" + " AS x, ST_Y(ST_Transform(geog::geometry, %(srid)s)) AS y, altitude, amplitude, error2d, stationcount " + "FROM WHERE \"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s") parameters = query.get_parameters() - assert_that(parameters.keys(), contains_inanyorder('srid', 'start_time', 'end_time')) - assert_that(parameters['start_time'], is_(self.start_time)) - assert_that(parameters['end_time'], is_(self.end_time)) - assert_that(parameters['srid'], is_(self.srid)) + assert_that(parameters.keys()).contains('srid', 'start_time', 'end_time') + assert_that(parameters['start_time']).is_equal_to(self.start_time) + assert_that(parameters['end_time']).is_equal_to(self.end_time) + assert_that(parameters['srid']).is_equal_to(self.srid) def test_grid_query(self): grid = Grid(11.0, 12.0, 51.0, 52.0, 0.1, 0.2, self.srid) query = self.query_builder.grid_query("", grid, count_threshold=0, time_interval=TimeInterval(self.start_time, self.end_time)) - assert_that(str(query), is_( + assert_that(str(query)).is_equal_to( "SELECT TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx, " "TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry, " "count(*) AS strike_count, max(\"timestamp\") as \"timestamp\" FROM " "WHERE ST_GeomFromWKB(%(envelope)s, %(envelope_srid)s) && geog AND " - "\"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s GROUP BY rx, ry")) + "\"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s GROUP BY rx, ry") parameters = query.get_parameters() - assert_that(parameters.keys(), - contains_inanyorder('xmin', 'ymin', 'xdiv', 'ydiv', 'envelope', 'envelope_srid', 'srid', - 'start_time', 'end_time')) - assert_that(parameters.keys(), not contains_inanyorder('count_threshold')) - assert_that(parameters['xmin'], is_(11.0)) - assert_that(parameters['ymin'], is_(51.0)) - assert_that(parameters['xdiv'], is_(0.1)) - assert_that(parameters['ydiv'], is_(0.2)) - assert_that(parameters['envelope'], is_(not_none())) - assert_that(parameters['envelope_srid'], is_(self.srid)) - assert_that(parameters['start_time'], is_(self.start_time)) - assert_that(parameters['end_time'], is_(self.end_time)) - assert_that(parameters['srid'], is_(self.srid)) + assert_that(parameters.keys()).contains('xmin', 'ymin', 'xdiv', 'ydiv', 'envelope', 'envelope_srid', 'srid', + 'start_time', 'end_time') + assert_that(parameters.keys()).does_not_contain('count_threshold') + assert_that(parameters['xmin']).is_equal_to(11.0) + assert_that(parameters['ymin']).is_equal_to(51.0) + assert_that(parameters['xdiv']).is_equal_to(0.1) + assert_that(parameters['ydiv']).is_equal_to(0.2) + assert_that(parameters['envelope']).is_not_none() + assert_that(parameters['envelope_srid']).is_equal_to(self.srid) + assert_that(parameters['start_time']).is_equal_to(self.start_time) + assert_that(parameters['end_time']).is_equal_to(self.end_time) + assert_that(parameters['srid']).is_equal_to(self.srid) def test_grid_query_with_count_threshold(self): grid = Grid(11.0, 12.0, 51.0, 52.0, 0.1, 0.2, self.srid) @@ -83,21 +81,21 @@ def test_grid_query_with_count_threshold(self): time_interval=TimeInterval(self.start_time, self.end_time)) parameters = query.get_parameters() - assert_that(parameters.keys(), - contains_inanyorder('count_threshold', 'xmin', 'ymin', 'xdiv', 'ydiv', 'envelope', 'envelope_srid', - 'srid', 'start_time', 'end_time')) - assert_that(parameters['count_threshold'], is_(5)) + assert_that(parameters.keys()).contains('count_threshold', 'xmin', 'ymin', 'xdiv', 'ydiv', 'envelope', + 'envelope_srid', + 'srid', 'start_time', 'end_time') + assert_that(parameters['count_threshold']).is_equal_to(5) - assert_that(str(query), is_( + assert_that(str(query)).is_equal_to( "SELECT TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx, " "TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry, " "count(*) AS strike_count, max(\"timestamp\") as \"timestamp\" FROM " "WHERE ST_GeomFromWKB(%(envelope)s, %(envelope_srid)s) && geog AND " "\"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s " - "GROUP BY rx, ry HAVING count(*) > %(count_threshold)s")) + "GROUP BY rx, ry HAVING count(*) > %(count_threshold)s") -class StrikeClusterTest(unittest.TestCase): +class StrikeClusterTest(object): def setUp(self): self.query_builder = blitzortung.db.query_builder.StrikeCluster() self.end_time = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC, second=0, microsecond=0) @@ -108,11 +106,11 @@ def test_select_query(self): query = self.query_builder.select_query("", self.srid, self.end_time, self.interval_duration, 6, self.interval_duration) - assert_that(str(query), is_( - "SELECT id, \"timestamp\", ST_Transform(geog::geometry, %(srid)s) as geom, strike_count FROM WHERE \"timestamp\" in %(timestamps)s AND interval_seconds=%(interval_seconds)s")) + assert_that(str(query)).is_equal_to( + "SELECT id, \"timestamp\", ST_Transform(geog::geometry, %(srid)s) as geom, strike_count FROM WHERE \"timestamp\" in %(timestamps)s AND interval_seconds=%(interval_seconds)s") parameters = query.get_parameters() - assert_that(parameters.keys(), contains_inanyorder('timestamps', 'srid', 'interval_seconds')) - assert_that(tuple(parameters['timestamps']), - is_(tuple(str(self.end_time - self.interval_duration * i) for i in range(0, 6)))) - assert_that(parameters['srid'], is_(self.srid)) - assert_that(parameters['interval_seconds'], is_(self.interval_duration.total_seconds())) + assert_that(parameters.keys()).contains('timestamps', 'srid', 'interval_seconds') + assert_that(tuple(parameters['timestamps'])).is_equal_to( + tuple(str(self.end_time - self.interval_duration * i) for i in range(0, 6))) + assert_that(parameters['srid']).is_equal_to(self.srid) + assert_that(parameters['interval_seconds']).is_equal_to(self.interval_duration.total_seconds()) diff --git a/tests/db/test_db_table.py b/tests/db/test_db_table.py index 26c1688..2a8c474 100644 --- a/tests/db/test_db_table.py +++ b/tests/db/test_db_table.py @@ -18,15 +18,13 @@ """ -import unittest import datetime +import psycopg2 import pytz +from assertpy import assert_that from mock import Mock, call -from hamcrest import assert_that, is_, equal_to, none -import psycopg2 -import blitzortung import blitzortung.db.table @@ -44,8 +42,8 @@ def select(self, *args): return args -class BaseTest(unittest.TestCase): - def setUp(self): +class BaseTest(object): + def setup_method(self): self.connection_pool = Mock() self.connection = self.connection_pool.getconn() self.cursor = self.connection.cursor() @@ -72,37 +70,37 @@ def test_initialize(self): def test_is_connected(self): self.connection.closed = True - assert_that(self.base.is_connected(), is_(False)) + assert_that(self.base.is_connected()).is_equal_to(False) self.connection.closed = False - assert_that(self.base.is_connected()) + assert_that(self.base.is_connected()).is_true() self.base.conn = None - assert_that(self.base.is_connected(), is_(False)) + assert_that(self.base.is_connected()).is_false() def test_full_table_name(self): - assert_that(self.base.full_table_name, is_("")) - assert_that(self.base.schema_name, is_("")) + assert_that(self.base.full_table_name).is_equal_to("") + assert_that(self.base.schema_name).is_equal_to("") self.base.table_name = "foo" - assert_that(self.base.full_table_name, is_("foo")) + assert_that(self.base.full_table_name).is_equal_to("foo") self.base.schema_name = "bar" - assert_that(self.base.full_table_name, is_('"bar"."foo"')) - assert_that(self.base.schema_name, is_("bar")) + assert_that(self.base.full_table_name).is_equal_to('"bar"."foo"') + assert_that(self.base.schema_name).is_equal_to("bar") def test_get_timezone(self): - assert_that(self.base.get_timezone(), is_(equal_to(pytz.UTC))) + assert_that(self.base.get_timezone()).is_equal_to(pytz.UTC) def test_fix_timezone(self): - assert_that(self.base.fix_timezone(None), is_(none())) + assert_that(self.base.fix_timezone(None)).is_none() time = datetime.datetime(2013, 1, 1, 12, 0, 0, tzinfo=pytz.timezone("CET")) utc_time = datetime.datetime(2013, 1, 1, 11, 0, 0, tzinfo=pytz.timezone("UTC")) - assert_that(self.base.fix_timezone(time), is_(utc_time)) + assert_that(self.base.fix_timezone(time)).is_equal_to(utc_time) def test_from_bare_utc_to_timezone(self): self.base.set_timezone(pytz.timezone("CET")) @@ -110,7 +108,7 @@ def test_from_bare_utc_to_timezone(self): time = datetime.datetime(2013, 1, 1, 12, 0, 0, tzinfo=pytz.timezone("CET")) utc_time = datetime.datetime(2013, 1, 1, 11, 0, 0) - assert_that(self.base.from_bare_utc_to_timezone(utc_time), is_(equal_to(time))) + assert_that(self.base.from_bare_utc_to_timezone(utc_time)).is_equal_to(time) def test_from_timezone_to_bare_utc(self): self.base.set_timezone(pytz.timezone("CET")) @@ -118,7 +116,7 @@ def test_from_timezone_to_bare_utc(self): time = datetime.datetime(2013, 1, 1, 12, 0, 0, tzinfo=pytz.timezone("CET")) utc_time = datetime.datetime(2013, 1, 1, 11, 0, 0) - assert_that(self.base.from_timezone_to_bare_utc(time), is_(equal_to(utc_time))) + assert_that(self.base.from_timezone_to_bare_utc(time)).is_equal_to(utc_time) def test_commit(self): self.connection.commit.assert_not_called() diff --git a/tests/test_builder.py b/tests/test_builder.py index e058970..b367e3d 100644 --- a/tests/test_builder.py +++ b/tests/test_builder.py @@ -18,25 +18,23 @@ """ -import unittest import datetime -from assertpy import assert_that -from nose.tools import raises +import pytest import pytz -import shapely.geometry +from assertpy import assert_that import blitzortung.builder from blitzortung.data import Timestamp -class TestBase(unittest.TestCase): +class TestBase(object): @staticmethod def get_timestamp(timestamp_string): return datetime.datetime.strptime(timestamp_string, '%Y-%m-%d %H:%M:%S.%f').replace(tzinfo=pytz.UTC) -class TimestampTest(unittest.TestCase): +class TimestampTest(object): def setUp(self): self.builder = blitzortung.builder.Timestamp() @@ -65,13 +63,15 @@ def test_value_property_with_nanoseconds(self): assert_that(value).is_equal_to(1328874978096651456) def test_value_property(self): - timestamp = self.builder.set_timestamp(datetime.datetime(2012, 2, 10, 12, 56, 18, 96651, tzinfo=pytz.UTC)).build() + timestamp = self.builder.set_timestamp( + datetime.datetime(2012, 2, 10, 12, 56, 18, 96651, tzinfo=pytz.UTC)).build() value = timestamp.value assert_that(value).is_equal_to(1328878578096651000) def test_value_property_with_nanoseconds(self): - timestamp = self.builder.set_timestamp(datetime.datetime(2012, 2, 10, 12, 56, 18, 96651, tzinfo=pytz.UTC), 456).build() + timestamp = self.builder.set_timestamp(datetime.datetime(2012, 2, 10, 12, 56, 18, 96651, tzinfo=pytz.UTC), + 456).build() value = timestamp.value assert_that(value).is_equal_to(1328878578096651456) @@ -200,10 +200,10 @@ def test_build_strike_from_line(self): [226, 529, 391, 233, 145, 398, 425, 533, 701, 336, 336, 515, 434, 392, 439, 283, 674, 573, 559, 364, 111, 43, 582, 594]) - @raises(blitzortung.builder.BuilderError) def test_build_strike_from_bad_line(self): strike_line = u"2013-08-08 10:30:03.644038642" - self.builder.from_line(strike_line) + with pytest.raises(blitzortung.builder.BuilderError): + self.builder.from_line(strike_line) class StationTest(TestBase): @@ -255,7 +255,7 @@ def test_build_station_offline(self): assert_that(station.board).is_equal_to('0815') -class StationOffline(unittest.TestCase): +class StationOffline(object): def setUp(self): self.builder = blitzortung.builder.StationOffline() @@ -282,7 +282,7 @@ def test_build_station_offline(self): assert_that(station_offline.end).is_equal_to(end) -class RawWaveformEventTest(unittest.TestCase): +class RawWaveformEventTest(object): def setUp(self): self.builder = blitzortung.builder.RawWaveformEvent(blitzortung.builder.ChannelWaveform()) @@ -325,7 +325,7 @@ def test_build_with_missing_bits_value(self): assert_that(channels[1].bits).is_equal_to(8) -class ChannelWaveformTest(unittest.TestCase): +class ChannelWaveformTest(object): def setUp(self): self.builder = blitzortung.builder.ChannelWaveform() @@ -372,4 +372,3 @@ def test_build_raw_red_event(self): assert_that(waveform[0]).is_equal_to(127) assert_that(waveform[1]).is_equal_to(0) assert_that(waveform[2]).is_equal_to(-128) - diff --git a/tests/test_cache.py b/tests/test_cache.py index 2efa0c2..d30cc9b 100644 --- a/tests/test_cache.py +++ b/tests/test_cache.py @@ -18,9 +18,10 @@ """ -from unittest import TestCase -from hamcrest import assert_that, is_, instance_of, is_not, same_instance, contains import time +from unittest import TestCase + +from assertpy import assert_that from mock import Mock from blitzortung.cache import CacheEntry, ObjectCache @@ -38,15 +39,15 @@ def test_is_valid(self): assert_that(not self.cache_entry.is_valid(time.time())) def test_get_payload(self): - assert_that(self.cache_entry.get_payload(), is_(self.payload)) + assert_that(self.cache_entry.get_payload()).is_equal_to(self.payload) def test_get_payload_increases_hit_count(self): self.cache_entry.get_payload() - assert_that(self.cache_entry.get_hit_count(), is_(1)) + assert_that(self.cache_entry.get_hit_count()).is_equal_to(1) def test_get_hit_count(self): - assert_that(self.cache_entry.get_hit_count(), is_(0)) + assert_that(self.cache_entry.get_hit_count()).is_equal_to(0) class TestObject(object): @@ -66,25 +67,25 @@ def setUp(self): self.cache = ObjectCache() def test_get_time_to_live_default_value(self): - assert_that(self.cache.get_time_to_live(), is_(30)) + assert_that(self.cache.get_time_to_live()).is_equal_to(30) def test_get_time_to_live(self): self.cache = ObjectCache(ttl_seconds=60) - assert_that(self.cache.get_time_to_live(), is_(60)) + assert_that(self.cache.get_time_to_live()).is_equal_to(60) def test_get(self): cached_object = self.cache.get(TestObject) - assert_that(cached_object, instance_of(TestObject)) + assert_that(cached_object).is_instance_of(TestObject) def test_get_caches_objects(self): cached_object = self.cache.get(TestObject) - assert_that(self.cache.get(TestObject), is_(same_instance(cached_object))) + assert_that(self.cache.get(TestObject)).is_same_as(cached_object) def test_clear_clears_cache(self): cached_object = self.cache.get(TestObject) self.cache.clear() - assert_that(self.cache.get(TestObject), is_not(same_instance(cached_object))) + assert_that(self.cache.get(TestObject)).is_not_same_as(cached_object) def test_clear_resets_counters(self): self.cache.get(TestObject) @@ -92,12 +93,12 @@ def test_clear_resets_counters(self): self.cache.clear() - assert_that(self.cache.get_ratio(), is_(0.0)) + assert_that(self.cache.get_ratio()).is_equal_to(0.0) def test_get_creates_new_object_if_original_object_is_expired(self): self.cache = ObjectCache(ttl_seconds=-10) cached_object = self.cache.get(TestObject) - assert_that(self.cache.get(TestObject), is_not(same_instance(cached_object))) + assert_that(self.cache.get(TestObject)).is_not_same_as(cached_object) def test_get_different_objects_for_different_create_objects(self): class OtherTestObject(TestObject): @@ -106,7 +107,7 @@ class OtherTestObject(TestObject): cached_object = self.cache.get(TestObject) other_cached_object = self.cache.get(OtherTestObject) - assert_that(cached_object, is_not(other_cached_object)) + assert_that(cached_object).is_not_equal_to(other_cached_object) def test_get_with_arg_is_called_with_same_arg(self): argument1 = object() @@ -114,14 +115,14 @@ def test_get_with_arg_is_called_with_same_arg(self): cached_object = self.cache.get(TestObject, argument1, argument2) - assert_that(cached_object.get_args(), contains(argument1, argument2)) + assert_that(cached_object.get_args()).contains(argument1, argument2) assert_that(not cached_object.get_kwargs()) def test_get_with_arg_is_cached(self): argument = object() cached_object = self.cache.get(TestObject, argument) - assert_that(self.cache.get(TestObject, argument), is_(same_instance(cached_object))) + assert_that(self.cache.get(TestObject, argument)).is_same_as(cached_object) def test_get_with_kwargs_is_called_with_same_kwargs(self): argument1 = object() @@ -130,20 +131,20 @@ def test_get_with_kwargs_is_called_with_same_kwargs(self): cached_object = self.cache.get(TestObject, foo=argument1, bar=argument2) assert_that(not cached_object.get_args()) - assert_that(cached_object.get_kwargs(), is_({'foo': argument1, 'bar': argument2})) + assert_that(cached_object.get_kwargs()).is_equal_to({'foo': argument1, 'bar': argument2}) def test_get_with_kwargs_is_cached(self): argument1 = object() argument2 = object() cached_object = self.cache.get(TestObject, foo=argument1, bar=argument2) - assert_that(self.cache.get(TestObject, bar=argument2, foo=argument1), is_(same_instance(cached_object))) + assert_that(self.cache.get(TestObject, bar=argument2, foo=argument1)).is_same_as(cached_object) def test_get_ratio(self): - assert_that(self.cache.get_ratio(), is_(0.0)) + assert_that(self.cache.get_ratio()).is_equal_to(0.0) self.cache.get(TestObject) - assert_that(self.cache.get_ratio(), is_(0.0)) + assert_that(self.cache.get_ratio()).is_equal_to(0.0) self.cache.get(TestObject) - assert_that(self.cache.get_ratio(), is_(0.5)) \ No newline at end of file + assert_that(self.cache.get_ratio()).is_equal_to(0.5) diff --git a/tests/test_config.py b/tests/test_config.py index de0bfd3..34d1fe0 100644 --- a/tests/test_config.py +++ b/tests/test_config.py @@ -19,8 +19,8 @@ """ import sys -import unittest -from hamcrest import assert_that, is_, equal_to, instance_of, contains, same_instance, has_item + +from assertpy import assert_that from mock import Mock, call, patch import blitzortung @@ -32,30 +32,30 @@ import ConfigParser as configparser -class TestConfig(unittest.TestCase): - def setUp(self): +class TestConfig(object): + def setup_method(self): self.config_parser = Mock() self.config = blitzortung.config.Config(self.config_parser) def test_get_username(self): self.config_parser.get.return_value = '' - assert_that(self.config.get_username(), is_(equal_to(''))) - assert_that(self.config_parser.mock_calls, contains(call.get('auth', 'username'))) + assert_that(self.config.get_username()).is_equal_to('') + assert_that(self.config_parser.mock_calls).contains(call.get('auth', 'username')) def test_get_password(self): self.config_parser.get.return_value = '' - assert_that(self.config.get_password(), is_(equal_to(''))) - assert_that(self.config_parser.mock_calls, contains(call.get('auth', 'password'))) + assert_that(self.config.get_password()).is_equal_to('') + assert_that(self.config_parser.mock_calls).contains(call.get('auth', 'password')) def test_get_raw_path(self): self.config_parser.get.return_value = '' - assert_that(self.config.get_raw_path(), is_(equal_to(''))) - assert_that(self.config_parser.mock_calls, contains(call.get('path', 'raw'))) + assert_that(self.config.get_raw_path()).is_equal_to('') + assert_that(self.config_parser.mock_calls).contains(call.get('path', 'raw')) def test_get_archive_path(self): self.config_parser.get.return_value = '' - assert_that(self.config.get_archive_path(), is_(equal_to(''))) - assert_that(self.config_parser.mock_calls, contains(call.get('path', 'archive'))) + assert_that(self.config.get_archive_path()).is_equal_to('') + assert_that(self.config_parser.mock_calls).contains(call.get('path', 'archive')) def test_get_db_connection_string(self): self.config_parser.get.side_effect = lambda *x: { @@ -64,48 +64,48 @@ def test_get_db_connection_string(self): ('db', 'username'): '', ('db', 'password'): ''}[x] - assert_that(self.config.get_db_connection_string(), - is_(equal_to("host='' dbname='' user='' password=''"))) + assert_that(self.config.get_db_connection_string()) \ + .is_equal_to("host='' dbname='' user='' password=''") - assert_that(self.config_parser.mock_calls, contains( + assert_that(self.config_parser.mock_calls).contains( call.get('db', 'host'), call.get('db', 'dbname'), call.get('db', 'username'), - call.get('db', 'password'))) + call.get('db', 'password')) def test_get_webservice_port(self): self.config_parser.get.return_value = 1234 - assert_that(self.config.get_webservice_port(), is_(equal_to(1234))) - assert_that(self.config_parser.mock_calls, contains(call.get('webservice', 'port'))) + assert_that(self.config.get_webservice_port()).is_equal_to(1234) + assert_that(self.config_parser.mock_calls).contains(call.get('webservice', 'port')) def test_string_representation(self): self.config_parser.get.side_effect = lambda *x: { ('auth', 'username'): '', ('auth', 'password'): ''}[x] - assert_that(str(self.config), is_(equal_to("Config(user: , pass: **********)"))) + assert_that(str(self.config)).is_equal_to("Config(user: , pass: **********)") - assert_that(self.config_parser.mock_calls, contains( + assert_that(self.config_parser.mock_calls).contains( call.get('auth', 'username'), - call.get('auth', 'password'))) + call.get('auth', 'password')) -class TestConfigModule(unittest.TestCase): +class TestConfigModule(object): - def setUp(self): + def setup_method(self): self.config_module = blitzortung.config.ConfigModule() @patch(config_parser_module + '.ConfigParser') def test_provide_config_parser(self, config_parser_class_mock): config_parser = self.config_module.provide_config_parser() - assert_that(config_parser, is_(config_parser_class_mock.return_value)) - assert_that(config_parser_class_mock.mock_calls, has_item(call())) - assert_that(config_parser.mock_calls, has_item(call.read('/etc/blitzortung.conf'))) + assert_that(config_parser).is_equal_to(config_parser_class_mock.return_value) + assert_that(config_parser_class_mock.mock_calls).contains(call()) + assert_that(config_parser.mock_calls).contains(call.read('/etc/blitzortung.conf')) @patch('blitzortung.INJECTOR') def test_get_config(self, injector_class_mock): config = Mock() injector_class_mock.get.return_value = config - assert_that(blitzortung.config.config(), is_(equal_to(config))) \ No newline at end of file + assert_that(blitzortung.config.config()).is_equal_to(config) diff --git a/tests/test_data.py b/tests/test_data.py index 9b67bf9..c9955b4 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -18,10 +18,9 @@ """ -import unittest import datetime + import pytz -import shapely.geometry from assertpy import assert_that import blitzortung @@ -29,7 +28,7 @@ from blitzortung.data import Timestamp, Timedelta, NaT -class TestTimestamp(unittest.TestCase): +class TestTimestamp(object): def test_value(self): now = Timestamp() later = now + 1234567 @@ -42,8 +41,16 @@ def test_difference(self): assert_that(later - now).is_equal_to(Timedelta(nanodelta=1234567)) + def test_from_nanoseconds(self): + timestamp = Timestamp(1540935833552753700) + + print(timestamp) + + assert_that(timestamp.datetime).is_equal_to(datetime.datetime(2018, 10, 30, 21, 43, 53, 552753, pytz.UTC)) + assert_that(timestamp.nanosecond).is_equal_to(700) + -class TestTimedelta(unittest.TestCase): +class TestTimedelta(object): def test_normalizing(self): assert_that(Timedelta(nanodelta=1500)).is_equal_to( Timedelta(datetime.timedelta(microseconds=1), 500)) @@ -55,12 +62,21 @@ def test_normalizing(self): Timedelta(datetime.timedelta(microseconds=-2), 500)) -class EventBaseTest(unittest.TestCase): - def setUp(self): +class EventBaseTest(object): + def setup_method(self): self.not_a_time = NaT self.now_time = Timestamp() self.later_time = self.now_time + 100 + def assertTrue(self, value): + assert_that(value).is_true() + + def assertFalse(self, value): + assert_that(value).is_false() + + def assertEqual(self, value, other): + assert_that(other).is_equal_to(value) + class TestEvent(EventBaseTest): def test_create_and_get_values(self): @@ -131,8 +147,8 @@ def test_is_valid_returning_false_if_event_is_not_valid(self): self.assertFalse(event.is_valid) -class TestStrike(unittest.TestCase): - def setUp(self): +class TestStrike(object): + def setup_method(self): self.timestamp = Timestamp('2013-09-28 23:23:38.123456', 789) self.strike = blitzortung.data.Strike(123, self.timestamp, 11.2, 49.3, 2500, 10.5, 5400, 11, [1, 5, 7, 15]) @@ -172,8 +188,8 @@ def test_string_represenation(self): assert_that(str(self.strike)).is_equal_to("2013-09-28 23:23:38.123456789 11.2000 49.3000 2500 10.5 5400 11") -class TestStation(unittest.TestCase): - def setUp(self): +class TestStation(object): + def setup_method(self): self.timestamp = Timestamp('2013-09-28 23:23:38') self.station = blitzortung.data.Station(123, 45, '', '', 11.2, 49.4, self.timestamp, '', '') @@ -203,8 +219,8 @@ def test_get_status(self): assert_that(self.station.status).is_equal_to('') -class TestGridData(unittest.TestCase): - def setUp(self): +class TestGridData(object): + def setup_method(self): self.reference_time = datetime.datetime.utcnow() self.grid = blitzortung.geom.Grid(-5, 4, -3, 2, 0.5, 1.25) self.grid_data = blitzortung.data.GridData(self.grid) diff --git a/tests/test_dataimport.py b/tests/test_dataimport.py index 3e1651e..800548b 100644 --- a/tests/test_dataimport.py +++ b/tests/test_dataimport.py @@ -19,20 +19,19 @@ """ from __future__ import unicode_literals -import unittest + import datetime -from nose.tools import raises -from hamcrest.library.collection.is_empty import empty -from mock import Mock, patch, call -from hamcrest import assert_that, is_, equal_to, has_item, contains +import pytest +from assertpy import assert_that +from mock import Mock, call import blitzortung -import blitzortung.dataimport import blitzortung.builder +import blitzortung.dataimport -class HttpDataTransportTest(unittest.TestCase): +class HttpDataTransportTest(object): def setUp(self): self.config = Mock(name='config') self.config.get_username.return_value = '' @@ -49,7 +48,7 @@ def test_read_lines_from_url(self): line_generator = self.data_transport.read_lines('http://foo.bar/baz') - assert_that(list(line_generator), contains('line1', 'line2')) + assert_that(list(line_generator)).contains('line1', 'line2') self.session.get.assert_called_with( 'http://foo.bar/baz', auth=('', ''), @@ -63,13 +62,13 @@ def test_read_data(self): result = self.data_transport.read_lines('target_url') - assert_that(list(result), contains(u'line1 ', u'line2', u'äöü')) + assert_that(list(result)).contains(u'line1 ', u'line2', u'äöü') def test_read_data_with_empty_response(self): self.response.iter_lines.return_value = [] result = self.data_transport.read_lines('foo') - assert_that(list(result), equal_to([])) + assert_that(list(result)).is_empty() def test_read_lines_from_url_with_post_process(self): self.response.status_code = 200 @@ -80,35 +79,35 @@ def test_read_lines_from_url_with_post_process(self): line_generator = self.data_transport.read_lines('http://foo.bar/baz', post_process=post_process) - assert_that(list(line_generator), contains('processed', 'lines')) + assert_that(list(line_generator)).contains('processed', 'lines') def test_read_from_url_with_error(self): self.response.status_code = 404 response = self.data_transport.read_lines('http://foo.bar/baz') - assert_that(list(response), is_([])) + assert_that(list(response)).is_empty() -class BlitzortungDataUrlTest(unittest.TestCase): +class BlitzortungDataUrlTest(object): def setUp(self): self.data_url = blitzortung.dataimport.BlitzortungDataPath() def test_default_values(self): target_url = self.data_url.build_path('url_path') - assert_that(target_url, is_(equal_to('http://data.blitzortung.org/Data_1/url_path'))) + assert_that(target_url).is_equal_to('http://data.blitzortung.org/Data_1/url_path') def test_specific_values(self): target_url = self.data_url.build_path('url_path', host_name='foo', region=42) - assert_that(target_url, is_(equal_to('http://foo.blitzortung.org/Data_42/url_path'))) + assert_that(target_url).is_equal_to('http://foo.blitzortung.org/Data_42/url_path') def test_with_user_defined_base(self): self.data_url = blitzortung.dataimport.BlitzortungDataPath("base/path") target_url = self.data_url.build_path('url_path', host_name='bar', region=39) - assert_that(target_url, is_(equal_to('base/path/Data_39/url_path'))) + assert_that(target_url).is_equal_to('base/path/Data_39/url_path') -class BlitzortungHistoryUrlGeneratorTest(unittest.TestCase): +class BlitzortungHistoryUrlGeneratorTest(object): def create_history_url_generator(self, present_time): self.present_time = present_time self.start_time = present_time - datetime.timedelta(minutes=25) @@ -119,14 +118,14 @@ def test_strike_url_iterator(self): urls = [url for url in self.strikes_url.get_paths(self.start_time, self.present_time)] - assert_that(urls, contains( + assert_that(urls).contains( '2013/08/20/11/40.log', '2013/08/20/11/50.log', '2013/08/20/12/00.log' - )) + ) -class StrikesBlitzortungDataProviderTest(unittest.TestCase): +class StrikesBlitzortungDataProviderTest(object): def setUp(self): self.data_provider = Mock() self.data_url = Mock() @@ -157,7 +156,7 @@ def test_get_strikes_since(self): strikes = self.provider.get_strikes_since(latest_strike_timestamp) - assert_that(list(strikes), contains(strike2)) + assert_that(list(strikes)).contains(strike2) def test_get_strikes_since_with_builder_error(self): now = datetime.datetime.utcnow() @@ -170,9 +169,8 @@ def test_get_strikes_since_with_builder_error(self): strikes = list(self.provider.get_strikes_since(latest_strike_timestamp)) - assert_that(strikes, is_(empty())) + assert_that(strikes).is_empty() - @raises(Exception) def test_get_strikes_since_with_generic_exception(self): now = datetime.datetime.utcnow() latest_strike_timestamp = now - datetime.timedelta(hours=1) @@ -182,10 +180,11 @@ def test_get_strikes_since_with_generic_exception(self): self.builder.from_data.return_value = self.builder self.builder.build.side_effect = Exception("foo") - list(self.provider.get_strikes_since(latest_strike_timestamp)) + with pytest.raises(Exception): + list(self.provider.get_strikes_since(latest_strike_timestamp)) -class StationsBlitzortungDataProviderTest(unittest.TestCase): +class StationsBlitzortungDataProviderTest(object): def setUp(self): self.data_provider = Mock() self.data_url = Mock() @@ -210,9 +209,9 @@ def test_get_stations(self): stations = self.provider.get_stations() expected_args = [call('full_url', post_process=self.provider.pre_process)] - assert_that(self.data_provider.read_lines.call_args_list, is_(equal_to(expected_args))) + assert_that(self.data_provider.read_lines.call_args_list).is_equal_to(expected_args) - assert_that(stations, contains(station1, station2)) + assert_that(stations).contains(station1, station2) def test_get_stations_with_builder_error(self): station_data = {'one': 1} @@ -222,51 +221,48 @@ def test_get_stations_with_builder_error(self): strikes = self.provider.get_stations() - assert_that(list(strikes), is_(empty())) - - -class RawSignalsBlitzortungDataProviderTest(unittest.TestCase): - def setUp(self): - self.data_provider = Mock() - self.data_url = Mock() - self.url_path_generator = Mock() - self.builder = Mock() - - self.provider = blitzortung.dataimport.RawSignalsBlitzortungDataProvider( - self.data_provider, - self.data_url, - self.url_path_generator, - self.builder - ) - - def test_get_raw_data_since(self): - last_data = datetime.datetime.utcnow() - datetime.timedelta(hours=1) - - self.data_url.build_path.side_effect = ['full_url1', 'full_url2'] - self.url_path_generator.get_paths.return_value = ['url_path1', 'url_path2'] - self.data_provider.read_lines.side_effect = [["line11", "line12"], ["line21", "line22"]] - raw11 = Mock(name='raw11') - raw12 = Mock(name='raw12') - raw21 = Mock(name='raw21') - raw22 = Mock(name='raw22') - self.builder.from_string.return_value = self.builder - self.builder.build.side_effect = [raw11, raw12, raw21, raw22] - - region_id = 5 - station_id = 123 - raw_signals = list(self.provider.get_raw_data_since(last_data, region_id, station_id)) - - expected_args = [call(last_data)] - assert_that(self.url_path_generator.get_paths.call_args_list, is_(equal_to(expected_args))) - - expected_args = [ - call('{}/url_path1'.format(station_id), region=region_id, host_name='signals'), - call('{}/url_path2'.format(station_id), region=region_id, host_name='signals')] - assert_that(self.data_url.build_path.call_args_list, is_(equal_to(expected_args))) - - expected_args = [call('full_url1'), call('full_url2')] - assert_that(self.data_provider.read_lines.call_args_list, is_(equal_to(expected_args))) - - assert_that(raw_signals, contains(raw11, raw12, raw21, raw22)) - - + assert_that(list(strikes)).is_empty() + + class RawSignalsBlitzortungDataProviderTest(object): + def setUp(self): + self.data_provider = Mock() + self.data_url = Mock() + self.url_path_generator = Mock() + self.builder = Mock() + + self.provider = blitzortung.dataimport.RawSignalsBlitzortungDataProvider( + self.data_provider, + self.data_url, + self.url_path_generator, + self.builder + ) + + def test_get_raw_data_since(self): + last_data = datetime.datetime.utcnow() - datetime.timedelta(hours=1) + + self.data_url.build_path.side_effect = ['full_url1', 'full_url2'] + self.url_path_generator.get_paths.return_value = ['url_path1', 'url_path2'] + self.data_provider.read_lines.side_effect = [["line11", "line12"], ["line21", "line22"]] + raw11 = Mock(name='raw11') + raw12 = Mock(name='raw12') + raw21 = Mock(name='raw21') + raw22 = Mock(name='raw22') + self.builder.from_string.return_value = self.builder + self.builder.build.side_effect = [raw11, raw12, raw21, raw22] + + region_id = 5 + station_id = 123 + raw_signals = list(self.provider.get_raw_data_since(last_data, region_id, station_id)) + + expected_args = [call(last_data)] + assert_that(self.url_path_generator.get_paths.call_args_list).is_equal_to(expected_args) + + expected_args = [ + call('{}/url_path1'.format(station_id), region=region_id, host_name='signals'), + call('{}/url_path2'.format(station_id), region=region_id, host_name='signals')] + assert_that(self.data_url.build_path.call_args_list).is_equal_to(expected_args) + + expected_args = [call('full_url1'), call('full_url2')] + assert_that(self.data_provider.read_lines.call_args_list).is_equal_to(expected_args) + + assert_that(raw_signals).contains(raw11, raw12, raw21, raw22) diff --git a/tests/test_geom.py b/tests/test_geom.py index 8bf9791..4e2988b 100644 --- a/tests/test_geom.py +++ b/tests/test_geom.py @@ -18,8 +18,8 @@ """ -from unittest import TestCase import datetime +from unittest import TestCase import pyproj import shapely.geometry @@ -140,7 +140,8 @@ def test_get_y_center(self): assert_that(self.grid.get_y_center(3)).is_equal_to(1.375) def test_repr(self): - assert_that(repr(self.grid)).is_equal_to("Grid(x: -5.0000..4.0000 (0.5000, #18), y: -3.0000..2.0000 (1.2500, #4))") + assert_that(repr(self.grid)).is_equal_to( + "Grid(x: -5.0000..4.0000 (0.5000, #18), y: -3.0000..2.0000 (1.2500, #4))") class TestGridFactory(TestCase): @@ -182,9 +183,6 @@ def test_get_for_cache(self): assert_that(grid_1).is_same_as(grid_2) - - - class TestRasterElement(TestCase): def setUp(self): self.timestamp = datetime.datetime(2013, 9, 6, 21, 36, 0, 123456) @@ -203,4 +201,4 @@ def test_comparison(self): assert_that(self.raster_element > other_raster_element) def test_string_representation(self): - assert_that(repr(self.raster_element)).is_equal_to("GridElement(1234, 2013-09-06 21:36:00.123456)") \ No newline at end of file + assert_that(repr(self.raster_element)).is_equal_to("GridElement(1234, 2013-09-06 21:36:00.123456)") diff --git a/tests/test_types.py b/tests/test_types.py index b276f9f..6cdf480 100644 --- a/tests/test_types.py +++ b/tests/test_types.py @@ -18,13 +18,12 @@ """ -import unittest import math import blitzortung.types -class PointTest(unittest.TestCase): +class PointTest(object): def setUp(self): self.point1 = blitzortung.types.Point(11, 49) self.point2 = blitzortung.types.Point(12, 49) diff --git a/tests/test_util.py b/tests/test_util.py index 4f83f4a..0a4f8b3 100644 --- a/tests/test_util.py +++ b/tests/test_util.py @@ -18,16 +18,15 @@ """ -import unittest import datetime -from hamcrest import assert_that, contains import pytz +from assertpy import assert_that import blitzortung.util -class TimeIntervalsTest(unittest.TestCase): +class TimeIntervalsTest(object): def setUp(self): self.duration = datetime.timedelta(minutes=10) @@ -40,34 +39,34 @@ def test_time_intervals_generator(self): times = [time for time in blitzortung.util.time_intervals(self.start_time, self.duration, self.end_time)] - assert_that(times, contains( + assert_that(times).contains( datetime.datetime(2013, 8, 20, 11, 40, 0), datetime.datetime(2013, 8, 20, 11, 50, 0), datetime.datetime(2013, 8, 20, 12, 0, 0), - )) + ) def test_time_intervals_generator_at_start_of_interval(self): self.initialize_times(datetime.datetime(2013, 8, 20, 12, 5, 0)) times = [time for time in blitzortung.util.time_intervals(self.start_time, self.duration, self.end_time)] - assert_that(times, contains( + assert_that(times).contains( datetime.datetime(2013, 8, 20, 11, 40, 0), datetime.datetime(2013, 8, 20, 11, 50, 0), datetime.datetime(2013, 8, 20, 12, 0, 0), - )) + ) def test_time_intervals_generator_before_start_of_interval(self): self.initialize_times(datetime.datetime(2013, 8, 20, 12, 4, 59)) times = [time for time in blitzortung.util.time_intervals(self.start_time, self.duration, self.end_time)] - assert_that(times, contains( + assert_that(times).contains( datetime.datetime(2013, 8, 20, 11, 30, 0), datetime.datetime(2013, 8, 20, 11, 40, 0), datetime.datetime(2013, 8, 20, 11, 50, 0), datetime.datetime(2013, 8, 20, 12, 0, 0), - )) + ) def test_time_intervals_generator_at_current_time(self): end_time = datetime.datetime.utcnow() @@ -76,7 +75,7 @@ def test_time_intervals_generator_at_current_time(self): times = [time for time in blitzortung.util.time_intervals(start_time, self.duration)] - assert_that(times, contains( + assert_that(times).contains( blitzortung.util.round_time(start_time, self.duration), blitzortung.util.round_time(end_time, self.duration) - )) + )