#!/usr/bin/env python3

import pytest

import sys

import time

import calendar

import datetime

from chronyk import LOCALTZ, Chronyk, ChronykDelta, currentutc, guesstype, DateRangeError

def isEqual(time1, time2):

return abs(time1 - time2) < 0.1

###############################################################################

def test_currentutc():

currentutc()

def test_guesstype():

assert guesstype(9001) == Chronyk(9001)

assert guesstype("2 hours ago").relativestring() == Chronyk("2 hours ago").relativestring()

assert guesstype("2 hours") == ChronykDelta("2 hours")

def test_empty_con():

assert isEqual(Chronyk().timestamp(), time.time())

def test_none_con():

assert isEqual(Chronyk(None).timestamp(), Chronyk(time.time()).timestamp())

def test_common_strings():

assert c1 == c2 and c2 == c3 and c3 == c4 and c4 == c5

def test_yesterday():

assert Chronyk("yesterday").relativestring() == "yesterday"

def test_yesteryear():

assert Chronyk("yesteryear").relativestring() == Chronyk("1 year ago").relativestring()

# TEST PRE-EPOCH DATES

def test_pre_epoch_1():

assert Chronyk(datetime.datetime(1950, 1, 1)).datetime() == datetime.datetime(1950, 1, 1)

def test_pre_epoch_2():

assert Chronyk(time.strptime("1950 01 01", "%Y %m %d")).timestring("%Y %m %d") == "1950 01 01"

# ABSOLUTE STRINGS

def test_absolute_iso():

t = Chronyk("2014-09-18 11:24:47")

assert t.ctime() == "Thu Sep 18 11:24:47 2014"

def test_absolute_iso_date():

t = Chronyk("2014-09-18")

assert t.ctime() == "Thu Sep 18 00:00:00 2014"

def test_absolute_written_1():

t = Chronyk("May 2nd, 2015")

assert t.ctime() == "Sat May 2 00:00:00 2015"

def test_absolute_written_2():

t = Chronyk("2. August 2010")

assert t.ctime() == "Mon Aug 2 00:00:00 2010"

def test_absolute_12hr():

t = Chronyk("11:14 am")

assert t.ctime()[11:-5] == "11:14:00"

def test_absolute_12hr_seconds():

t = Chronyk("11:14:32 am")

assert t.ctime()[11:-5] == "11:14:32"

def test_absolute_24hr():

t = Chronyk("17:14")

assert t.ctime()[11:-5] == "17:14:00"

def test_absolute_24hr_seconds():

t = Chronyk("17:14:32")

assert t.ctime()[11:-5] == "17:14:32"

def test_absolute_value():

with pytest.raises(ValueError):

Chronyk("warglblargl")

# RELATIVE STRINGS

def test_relative_now():

assert Chronyk().relativestring() == "just now"

def test_relative_seconds_1():

assert Chronyk("2 seconds ago").relativestring() == "just now"

def test_relative_seconds_2():

assert Chronyk("in 5 seconds").relativestring() == "just now"

def test_relative_seconds_3():

timest = time.time()

assert Chronyk(timest - 5).relativestring(now=timest, minimum=0) == "5 seconds ago"

def test_relative_minutes_1():

assert Chronyk("1 minute ago").relativestring() == "1 minute ago"

def test_relative_minutes_2():

assert Chronyk("in 2 minutes").relativestring() == "in 2 minutes"

def test_relative_hours_1():

assert Chronyk("1 hour ago").relativestring() == "1 hour ago"

def test_relative_hours_2():

assert Chronyk("in 2 hours").relativestring() == "in 2 hours"

def test_relative_days_1():

assert Chronyk("10 days ago").relativestring() == "10 days ago"

def test_relative_days_2():

assert Chronyk("in 20 days").relativestring() == "in 20 days"

def test_relative_weeks_1():

assert Chronyk("1 week ago").relativestring() == "7 days ago"

def test_relative_weeks_2():

assert Chronyk("in 2 weeks").relativestring() == "in 14 days"

def test_relative_weeks_3():

assert Chronyk("in blurgh weeks and 2 days").relativestring() == "in 2 days"

def test_relative_months_1():

assert Chronyk("overninethousand months and 2 days ago").relativestring() == "2 days ago"

def test_relative_months_2():

assert Chronyk("in 4 months", timezone=0).relativestring() == timestr

def test_relative_years_1():

assert Chronyk("something years and 2 days ago").relativestring() == "2 days ago"

def test_relative_years_2():

assert Chronyk("2 years ago").relativestring() == timestr

def test_struct():

timestr = time.localtime()

assert Chronyk(timestr).timestamp() == time.mktime(timestr)

def test_valid_1():

Chronyk("2 hours ago", allowfuture=False, allowpast=True)

def test_valid_2():

Chronyk("in 2 hours", allowfuture=True, allowpast=False)

def test_valid_3():

with pytest.raises(DateRangeError):

Chronyk("2 hours ago", allowpast=False)

def test_valid_4():

with pytest.raises(DateRangeError):

Chronyk("in 2 hours", allowfuture=False)

def test_typeerror():

with pytest.raises(TypeError):

Chronyk(["this", "should", "throw", "TypeError"])

def test_datetime():

timest = currentutc()

assert Chronyk(timest, timezone=0).datetime() == datetime.datetime.fromtimestamp(timest)

def test_date():

timest = currentutc()

assert Chronyk(timest, timezone=0).date() == datetime.date.fromtimestamp(timest)

def test_timest_1():

timest = time.time()

assert Chronyk(timest).timestamp() == timest

def test_timest_2():

timest = time.time()

assert Chronyk(timest, timezone=0).timestamp(timezone=-7200) == timest + 7200

def test_timest_3():

timest = time.time()

assert Chronyk(timest, timezone=-7200).timestamp(timezone=0) == timest - 7200

def test_timestring_1():

timest = time.time()

assert Chronyk(timest).timestring() == time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timest - LOCALTZ))

def test_timestring_2():

timest = time.time()

assert Chronyk(timest).timestring("%Y-%m-%d") == time.strftime("%Y-%m-%d", time.gmtime(timest - LOCALTZ))

def test_operators_eq():

timest = time.time()

assert Chronyk(timest) - 5 == Chronyk(timest - 5) and Chronyk(timest, timezone=0) == timest

def test_operators_str():

t = Chronyk()

assert str(t) == t.timestring()

def test_operators_num():

timest = time.time()

t = Chronyk(timest, timezone=0)

assert int(timest) == int(t) and int(t) == int(float(t))

def test_operators_ne():

timest = time.time()

assert Chronyk(timest) != Chronyk(timest - 2)

def test_operators_ltgt():

assert Chronyk(timest, timezone=0) >= timest - 5

def test_operators_add():

timest = time.time()

assert Chronyk(timest) + ChronykDelta(5) == Chronyk(timest + 5)

assert Chronyk(timest) + 5 == Chronyk(timest + 5)

def test_operators_sub():

assert Chronyk(timest, timezone=0) - 5 == timest - 5

def test_delta_type():

with pytest.raises(TypeError):

ChronykDelta(["WEEE", "EEEEE", "EEEEEE"])

def test_delta_timestring_1():

assert ChronykDelta("5 hours").timestring() == "5 hours"

def test_delta_timestring_2():

assert ChronykDelta("1 week").timestring() == "7 days"

def test_delta_timestring_3():

assert ChronykDelta("1 hour").timestring() == "1 hour"

def test_delta_timestring_4():

assert ChronykDelta("1 day and 12 hours").timestring() == "1 day and 12 hours"

def test_delta_timestring_5():

assert ChronykDelta("1 day and 12 hours").timestring(maxunits=1) == "1 day"

def test_delta_timestring_6():

with pytest.raises(ValueError):

ChronykDelta("1 day ago").timestring(maxunits=0)

def test_delta_timestring_7():

assert ChronykDelta(0).timestring() == ""

def test_delta_operators_str():

assert ChronykDelta(5).timestring() == str(ChronykDelta(5))

def test_delta_operators_num():

assert 5 == int(ChronykDelta(5)) and int(ChronykDelta(5)) == float(ChronykDelta(5))

def test_delta_operators_eq():

assert ChronykDelta(5) == ChronykDelta(5) and ChronykDelta(5) == 5

def test_delta_operators_neq():

assert ChronykDelta(5) != ChronykDelta(6) and ChronykDelta(5) != 3

def test_delta_operators_ltgt():

assert ChronykDelta(5) <= 5 and ChronykDelta(5) <= ChronykDelta(6)

def test_delta_operators_add():

assert ChronykDelta(5) + 10 == 15

def test_delta_operators_sub():

assert ChronykDelta(5) - 5 == 0

assert ChronykDelta(5) - ChronykDelta(1) == 4

def test_delta_operators_mul():

assert ChronykDelta(12) * 2 == 24

def test_delta_operators_div():

assert ChronykDelta(10) / 2 == 5

if __name__ == "__main__":

sys.exit(pytest.main())