def test_timezone_conversion(self):
from faker.providers.date_time import datetime_to_timestamp
now = datetime.now(utc).replace(microsecond=0)
timestamp = datetime_to_timestamp(now)
now_back = datetime.fromtimestamp(timestamp, utc)
self.assertEqual(now, now_back)
today = date.today()
timestamp = datetime_to_timestamp(today)
today_back = datetime.fromtimestamp(timestamp, utc).date()
self.assertEqual(today, today_back)
def test_timezone_conversion(self):
from faker.providers.date_time import datetime_to_timestamp
now = datetime.datetime.now(utc).replace(microsecond=0)
timestamp = datetime_to_timestamp(now)
now_back = datetime.datetime.fromtimestamp(timestamp, utc)
self.assertEqual(now, now_back)
today = datetime.date.today()
timestamp = datetime_to_timestamp(today)
today_as_dt = datetime.datetime.combine(today, datetime.time.min)
today_back = datetime.datetime.fromtimestamp(timestamp)
self.assertEqual(today_as_dt, today_back)
def test_timezone_conversion(self):
from faker.providers.date_time import datetime_to_timestamp
now = datetime.datetime.now(utc).replace(microsecond=0)
timestamp = datetime_to_timestamp(now)
now_back = datetime.datetime.fromtimestamp(timestamp, utc)
self.assertEqual(now, now_back)
def test_unix_time(self):
from faker.providers.date_time import datetime_to_timestamp
for _ in range(100):
now = datetime.now().replace(microsecond=0)
epoch_start = datetime(1970, 1, 1, tzinfo=utc)
# Ensure doubly-constrained unix_times are generated correctly
start_datetime = datetime(2001, 1, 1, tzinfo=utc)
end_datetime = datetime(2001, 1, 2, tzinfo=utc)
constrained_unix_time = self.fake.unix_time(
end_datetime=end_datetime, start_datetime=start_datetime)
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(
constrained_unix_time,
datetime_to_timestamp(start_datetime),
datetime_to_timestamp(end_datetime),
)
# Ensure relative unix_times partially-constrained by a start time are generated correctly
one_day_ago = datetime.today() - timedelta(days=1)
recent_unix_time = self.fake.unix_time(start_datetime=one_day_ago)
self.assertIsInstance(recent_unix_time, int)
self.assertBetween(
recent_unix_time,
datetime_to_timestamp(one_day_ago),
datetime_to_timestamp(now),
)
# Ensure relative unix_times partially-constrained by an end time are generated correctly
one_day_after_epoch_start = datetime(1970, 1, 2, tzinfo=utc)
distant_unix_time = self.fake.unix_time(
end_datetime=one_day_after_epoch_start)
self.assertIsInstance(distant_unix_time, int)
self.assertBetween(
distant_unix_time,
datetime_to_timestamp(epoch_start),
datetime_to_timestamp(one_day_after_epoch_start),
)
# Ensure wide-open unix_times are generated correctly
self.fake.unix_time()
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(constrained_unix_time, 0,
datetime_to_timestamp(now))
# Ensure it does not throw error with startdate='now' for machines with negative offset
if platform.system() != "Windows":
os.environ["TZ"] = "Europe/Paris"
time.tzset()
self.fake.unix_time(start_datetime="now")
if platform.system() != "Windows":
del os.environ["TZ"]
def test_unix_time(self):
from faker.providers.date_time import datetime_to_timestamp
for _ in range(100):
now = datetime.now(utc).replace(microsecond=0)
epoch_start = datetime(1970, 1, 1, tzinfo=utc)
# Ensure doubly-constrained unix_times are generated correctly
start_datetime = datetime(2001, 1, 1, tzinfo=utc)
end_datetime = datetime(2001, 1, 2, tzinfo=utc)
constrained_unix_time = self.factory.unix_time(
end_datetime=end_datetime, start_datetime=start_datetime)
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(
constrained_unix_time,
datetime_to_timestamp(start_datetime),
datetime_to_timestamp(end_datetime),
)
# Ensure relative unix_times partially-constrained by a start time are generated correctly
one_day_ago = datetime.today() - timedelta(days=1)
recent_unix_time = self.factory.unix_time(
start_datetime=one_day_ago)
self.assertIsInstance(recent_unix_time, int)
self.assertBetween(recent_unix_time,
datetime_to_timestamp(one_day_ago),
datetime_to_timestamp(now))
# Ensure relative unix_times partially-constrained by an end time are generated correctly
one_day_after_epoch_start = datetime(1970, 1, 2, tzinfo=utc)
distant_unix_time = self.factory.unix_time(
end_datetime=one_day_after_epoch_start)
self.assertIsInstance(distant_unix_time, int)
self.assertBetween(
distant_unix_time,
datetime_to_timestamp(epoch_start),
datetime_to_timestamp(one_day_after_epoch_start),
)
# Ensure wide-open unix_times are generated correctly
self.factory.unix_time()
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(constrained_unix_time, 0,
datetime_to_timestamp(now))
def test_unix_time(self):
from faker.providers.date_time import datetime_to_timestamp
for _ in range(100):
now = datetime.now(utc).replace(microsecond=0)
epoch_start = datetime(1970, 1, 1, tzinfo=utc)
# Ensure doubly-constrained unix_times are generated correctly
start_datetime = datetime(2001, 1, 1, tzinfo=utc)
end_datetime = datetime(2001, 1, 2, tzinfo=utc)
constrained_unix_time = self.factory.unix_time(end_datetime=end_datetime, start_datetime=start_datetime)
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(
constrained_unix_time,
datetime_to_timestamp(start_datetime),
datetime_to_timestamp(end_datetime),
)
# Ensure relative unix_times partially-constrained by a start time are generated correctly
one_day_ago = datetime.today()-timedelta(days=1)
recent_unix_time = self.factory.unix_time(start_datetime=one_day_ago)
self.assertIsInstance(recent_unix_time, int)
self.assertBetween(recent_unix_time, datetime_to_timestamp(one_day_ago), datetime_to_timestamp(now))
# Ensure relative unix_times partially-constrained by an end time are generated correctly
one_day_after_epoch_start = datetime(1970, 1, 2, tzinfo=utc)
distant_unix_time = self.factory.unix_time(end_datetime=one_day_after_epoch_start)
self.assertIsInstance(distant_unix_time, int)
self.assertBetween(
distant_unix_time,
datetime_to_timestamp(epoch_start),
datetime_to_timestamp(one_day_after_epoch_start),
)
# Ensure wide-open unix_times are generated correctly
self.factory.unix_time()
self.assertIsInstance(constrained_unix_time, int)
self.assertBetween(constrained_unix_time, 0, datetime_to_timestamp(now))
