nepali 0.5.5__py3-none-any.whl → 1.2.0__py3-none-any.whl

nepali/tests/test_parser.py

@@ -8,9 +8,9 @@ from nepali.exceptions import FormatNotMatchException, InvalidDateTimeFormatExce
 
 
 class TestNepaliDateTimeParserValidators(unittest.TestCase):
-    '''
+    """
     Tests nepali date
-    '''
+    """
 
     def setUp(self) -> None:
         self.nepali_time_re = NepaliTimeRE()
@@ -20,89 +20,100 @@ class TestNepaliDateTimeParserValidators(unittest.TestCase):
 
     def test_simple_extract(self):
         extracted_data = extract("2078-01-12", format="%Y-%m-%d")
-        self.assertEqual(extracted_data.get('Y'), '2078')
-        self.assertEqual(extracted_data.get('m'), '01')
-        self.assertEqual(extracted_data.get('d'), '12')
+        self.assertEqual(extracted_data.get("Y"), "2078")
+        self.assertEqual(extracted_data.get("m"), "01")
+        self.assertEqual(extracted_data.get("d"), "12")
 
     def test_complex_extract(self):
-        extracted_data = extract("Wed Wednesday 3 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23", format="%a %A %w %d %b %B %m %y %Y %H %I %p %M %S")
-        self.assertEqual(extracted_data.get('a'), 'Wed')
-        self.assertEqual(extracted_data.get('A'), 'Wednesday')
-        self.assertEqual(extracted_data.get('w'), '3')
-        self.assertEqual(extracted_data.get('d'), '28')
-        self.assertEqual(extracted_data.get('b'), 'Sharwan')
-        self.assertEqual(extracted_data.get('B'), 'Sharwan')
-        self.assertEqual(extracted_data.get('m'), '04')
-        self.assertEqual(extracted_data.get('y'), '51')
-        self.assertEqual(extracted_data.get('Y'), '2051')
-        self.assertEqual(extracted_data.get('H'), '05')
-        self.assertEqual(extracted_data.get('I'), '05')
-        self.assertEqual(extracted_data.get('p'), 'AM')
-        self.assertEqual(extracted_data.get('M'), '28')
-        self.assertEqual(extracted_data.get('S'), '23')
+        extracted_data = extract(
+            "Wed Wednesday 3 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23",
+            format="%a %A %w %d %b %B %m %y %Y %H %I %p %M %S",
+        )
+        self.assertEqual(extracted_data.get("a"), "Wed")
+        self.assertEqual(extracted_data.get("A"), "Wednesday")
+        self.assertEqual(extracted_data.get("w"), "3")
+        self.assertEqual(extracted_data.get("d"), "28")
+        self.assertEqual(extracted_data.get("b"), "Sharwan")
+        self.assertEqual(extracted_data.get("B"), "Sharwan")
+        self.assertEqual(extracted_data.get("m"), "04")
+        self.assertEqual(extracted_data.get("y"), "51")
+        self.assertEqual(extracted_data.get("Y"), "2051")
+        self.assertEqual(extracted_data.get("H"), "05")
+        self.assertEqual(extracted_data.get("I"), "05")
+        self.assertEqual(extracted_data.get("p"), "AM")
+        self.assertEqual(extracted_data.get("M"), "28")
+        self.assertEqual(extracted_data.get("S"), "23")
 
     def test_nepali_to_english_text_conversion(self):
         self.assertEqual(
-            nepali_to_english_text('बुध बुधबार ३ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३'),
-            'Wed Wednesday 3 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23'
+            nepali_to_english_text(
+                "बुध बुधबार ३ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३"
+            ),
+            "Wed Wednesday 3 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23",
         )
 
     def test_complex_extract_in_nepali(self):
-        extracted_data = extract("बुध बुधबार ३ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३", format="%a %A %w %d %b %B %m %y %Y %H %I %p %M %S")
-        self.assertEqual(extracted_data.get('a'), 'Wed')
-        self.assertEqual(extracted_data.get('A'), 'Wednesday')
-        self.assertEqual(extracted_data.get('w'), '3')
-        self.assertEqual(extracted_data.get('d'), '28')
-        self.assertEqual(extracted_data.get('b'), 'Sharwan')
-        self.assertEqual(extracted_data.get('B'), 'Sharwan')
-        self.assertEqual(extracted_data.get('m'), '04')
-        self.assertEqual(extracted_data.get('y'), '51')
-        self.assertEqual(extracted_data.get('Y'), '2051')
-        self.assertEqual(extracted_data.get('H'), '05')
-        self.assertEqual(extracted_data.get('I'), '05')
-        self.assertEqual(extracted_data.get('p'), 'AM')
-        self.assertEqual(extracted_data.get('M'), '28')
-        self.assertEqual(extracted_data.get('S'), '23')
-
+        extracted_data = extract(
+            "बुध बुधबार ३ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३",
+            format="%a %A %w %d %b %B %m %y %Y %H %I %p %M %S",
+        )
+        self.assertEqual(extracted_data.get("a"), "Wed")
+        self.assertEqual(extracted_data.get("A"), "Wednesday")
+        self.assertEqual(extracted_data.get("w"), "3")
+        self.assertEqual(extracted_data.get("d"), "28")
+        self.assertEqual(extracted_data.get("b"), "Sharwan")
+        self.assertEqual(extracted_data.get("B"), "Sharwan")
+        self.assertEqual(extracted_data.get("m"), "04")
+        self.assertEqual(extracted_data.get("y"), "51")
+        self.assertEqual(extracted_data.get("Y"), "2051")
+        self.assertEqual(extracted_data.get("H"), "05")
+        self.assertEqual(extracted_data.get("I"), "05")
+        self.assertEqual(extracted_data.get("p"), "AM")
+        self.assertEqual(extracted_data.get("M"), "28")
+        self.assertEqual(extracted_data.get("S"), "23")
 
     # test transform
     def test_transform(self):
-        data = transform({
-            'Y': '2078',
-            'b': 'MAngsir',
-            'd': '12',
-            'p': 'pm',
-            'I': '05',
-            'M': '25',
-            'S': '31',
-            'f': '455',
-            'a': 'Wed',
-        })
-        self.assertEqual(data.get('year'), 2078)
-        self.assertEqual(data.get('month'), 8)
-        self.assertEqual(data.get('day'), 12)
-        self.assertEqual(data.get('hour'), 17)
-        self.assertEqual(data.get('minute'), 25)
-        self.assertEqual(data.get('second'), 31)
-        self.assertEqual(data.get('microsecond'), 455000)
-        self.assertEqual(data.get('weekday'), 4)
+        data = transform(
+            {
+                "Y": "2078",
+                "b": "MAngsir",
+                "d": "12",
+                "p": "pm",
+                "I": "05",
+                "M": "25",
+                "S": "31",
+                "f": "455",
+                "a": "Wed",
+            }
+        )
+        self.assertEqual(data.get("year"), 2078)
+        self.assertEqual(data.get("month"), 8)
+        self.assertEqual(data.get("day"), 12)
+        self.assertEqual(data.get("hour"), 17)
+        self.assertEqual(data.get("minute"), 25)
+        self.assertEqual(data.get("second"), 31)
+        self.assertEqual(data.get("microsecond"), 455000)
+        self.assertEqual(data.get("weekday"), 3)
 
     #
     # test validate
 
     def test_validate(self):
-        nepalidatetime_obj = validate('2078-01-12', format='%Y-%m-%d')
+        nepalidatetime_obj = validate("2078-01-12", format="%Y-%m-%d")
         self.assertEqual(nepalidatetime_obj.year, 2078)
         self.assertEqual(nepalidatetime_obj.month, 1)
         self.assertEqual(nepalidatetime_obj.day, 12)
 
-        nepalidatetime_obj = validate('2079-03-32', format='%Y-%m-%d')
+        nepalidatetime_obj = validate("2079-03-32", format="%Y-%m-%d")
         self.assertEqual(nepalidatetime_obj.year, 2079)
         self.assertEqual(nepalidatetime_obj.month, 3)
         self.assertEqual(nepalidatetime_obj.day, 32)
 
     def test_test_validate(self):
-        nepalidatetime_obj = validate('29 Jestha, 2078, 1:30 PM', format='%d %B, %Y, %I:%M %p')
+        nepalidatetime_obj = validate(
+            "29 Jestha, 2078, 1:30 PM", format="%d %B, %Y, %I:%M %p"
+        )
         self.assertEqual(nepalidatetime_obj.year, 2078)
         self.assertEqual(nepalidatetime_obj.month, 2)
         self.assertEqual(nepalidatetime_obj.day, 29)
@@ -111,35 +122,37 @@ class TestNepaliDateTimeParserValidators(unittest.TestCase):
         self.assertEqual(nepalidatetime_obj.second, 0)
 
     def test_validate_with_invalid_data(self):
-        self.assertEqual(validate('2078-01-12', format='%k-%m-%d'), None)
-        self.assertEqual(validate('2078-01-12', format='%m-%M-%Y'), None)
+        self.assertEqual(validate("2078-01-12", format="%k-%m-%d"), None)
+        self.assertEqual(validate("2078-01-12", format="%m-%M-%Y"), None)
 
 
 class TestNepaliDateTimeParser(unittest.TestCase):
-    '''
+    """
     Tests nepali datetime parser.
-    '''
+    """
 
     # test strptime
     def test_strptime(self):
-        nepalidatetime_obj = nepalidatetime_parser.strptime('2078-01-12', format='%Y-%m-%d')
+        nepalidatetime_obj = nepalidatetime_parser.strptime(
+            "2078-01-12", format="%Y-%m-%d"
+        )
         self.assertEqual(nepalidatetime_obj.year, 2078)
         self.assertEqual(nepalidatetime_obj.month, 1)
         self.assertEqual(nepalidatetime_obj.day, 12)
 
     def test_strptime_fail(self):
         with self.assertRaises(FormatNotMatchException):
-            nepalidatetime_parser.strptime('2078-01-12', format='%Y %d')
+            nepalidatetime_parser.strptime("2078-01-12", format="%Y %d")
 
     # test parser
 
     def test_normal_string_parse(self):
-        parsed_datetime = nepalidatetime_parser.parse('2071-01-24')
+        parsed_datetime = nepalidatetime_parser.parse("2071-01-24")
         test_datetime = nepalidatetime(2071, 1, 24)
         self.assertEqual(parsed_datetime, test_datetime)
 
     def test_complex_string_parse(self):
-        nepalidatetime_obj = nepalidatetime_parser.parse('29 Jestha, 2078, 1:30 PM')
+        nepalidatetime_obj = nepalidatetime_parser.parse("29 Jestha, 2078, 1:30 PM")
         self.assertEqual(nepalidatetime_obj.year, 2078)
         self.assertEqual(nepalidatetime_obj.month, 2)
         self.assertEqual(nepalidatetime_obj.day, 29)
@@ -148,4 +161,4 @@ class TestNepaliDateTimeParser(unittest.TestCase):
 
     def test_parse_failed(self):
         with self.assertRaises(InvalidDateTimeFormatException):
-            nepalidatetime_parser.parse('')
+            nepalidatetime_parser.parse("")

nepali/tests/test_phone_number.py

@@ -0,0 +1,254 @@
+import unittest
+from unittest import mock
+
+from nepali.phone_number import (
+    Operator,
+    _get_area_code,
+    _get_operator,
+    _parse_landline_number,
+    _parse_mobile_number,
+    get_exact_number,
+    is_landline_number,
+    is_mobile_number,
+    is_valid,
+    parse,
+)
+
+
+class TestOperator(unittest.TestCase):
+    def test_operator_with_invalid_data(self):
+        with self.assertRaises(ValueError):
+            Operator("Hello")
+
+    def test_operator_with_valid_data(self):
+        operator = Operator("Nepal Telecom")
+        self.assertEqual(operator, Operator.NEPAL_TELECOM)
+
+    def test_operator_str(self):
+        operator = Operator.NEPAL_TELECOM
+        self.assertEqual(str(operator), operator.value)
+
+    def test_operator_repr(self):
+        operator = Operator.NEPAL_TELECOM
+        self.assertEqual(repr(operator), f"<Operator: {operator.value}>")
+
+
+class TestPhoneNumberValidation(unittest.TestCase):
+    def test_is_mobile_number(self):
+        # True case
+        self.assertEqual(is_mobile_number("9779842536789"), True)
+        self.assertEqual(is_mobile_number("+9779842536789"), True)
+        self.assertEqual(is_mobile_number("+977-9842536789"), True)
+        self.assertEqual(is_mobile_number("9842536789"), True)
+        self.assertEqual(is_mobile_number("9852536789"), True)
+        self.assertEqual(is_mobile_number("9862536789"), True)
+        self.assertEqual(is_mobile_number("9742536789"), True)
+        self.assertEqual(is_mobile_number("9752536789"), True)
+        self.assertEqual(is_mobile_number("9802536789"), True)
+        self.assertEqual(is_mobile_number("9812536789"), True)
+        self.assertEqual(is_mobile_number("9822536789"), True)
+        self.assertEqual(is_mobile_number("9612536789"), True)
+        self.assertEqual(is_mobile_number("9622536789"), True)
+        self.assertEqual(is_mobile_number("9882536789"), True)
+        self.assertEqual(is_mobile_number("9722536789"), True)
+        self.assertEqual(is_mobile_number("9632536789"), True)
+
+        # False case
+        self.assertEqual(is_mobile_number(None), False)  # type: ignore
+        self.assertEqual(is_mobile_number(""), False)
+        self.assertEqual(is_mobile_number("test"), False)
+        self.assertEqual(is_mobile_number("977test"), False)
+        self.assertEqual(is_mobile_number("+977test"), False)
+        self.assertEqual(is_mobile_number("+977-test"), False)
+        self.assertEqual(is_mobile_number("9551088967"), False)
+        self.assertEqual(is_mobile_number("+977-98425367899"), False)
+        self.assertEqual(is_mobile_number("+977-984253678"), False)
+        self.assertEqual(is_mobile_number("984253678"), False)
+        self.assertEqual(is_mobile_number("98425367899"), False)
+
+    def test_is_landline_number(self):
+        # True case
+        self.assertEqual(is_landline_number("14231481"), True)
+        self.assertEqual(is_landline_number("014231481"), True)
+        self.assertEqual(is_landline_number("0215154579"), True)
+        self.assertEqual(is_landline_number("+977-142314819"), True)
+        self.assertEqual(is_landline_number("0154225639"), True)
+        self.assertEqual(is_landline_number("9770154225639"), True)
+        self.assertEqual(is_landline_number("0565114679"), True)
+        self.assertEqual(is_landline_number("021420451"), True)
+        self.assertEqual(is_landline_number("21420451"), True)
+        self.assertEqual(is_landline_number("+977-0565114679"), True)
+
+        # False case
+        self.assertEqual(is_landline_number(None), False)  # type: ignore
+        self.assertEqual(is_landline_number(""), False)
+        self.assertEqual(is_landline_number("test"), False)
+        self.assertEqual(is_landline_number("977test"), False)
+        self.assertEqual(is_landline_number("+977test"), False)
+        self.assertEqual(is_landline_number("+977-test"), False)
+
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=False)
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=False)
+    def test_if__is_valid__returns_false_for_invalid_numbers(self, *_):
+        self.assertEqual(is_valid("who_cares"), False)
+
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=True)
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=False)
+    def test_if__is_valid__returns_true_for_landline(self, *_):
+        self.assertEqual(is_valid("who_cares"), True)
+
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=False)
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=True)
+    def test_if__is_valid__returns_true_for_mobile(self, *_):
+        self.assertEqual(is_valid("who_cares"), True)
+
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=True)
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=True)
+    def test_if__is_valid__returns_true_if_both_mobile_and_landline_returns_true(
+        self, *_
+    ):
+        self.assertEqual(is_valid("who_cares"), True)
+
+
+class TestPhoneNumberFunctions(unittest.TestCase):
+    def test_get_exact_number(self):
+        self.assertEqual(get_exact_number("9842536789"), "9842536789")
+        self.assertEqual(get_exact_number("9779842536789"), "9842536789")
+        self.assertEqual(get_exact_number("+9779842536789"), "9842536789")
+        self.assertEqual(get_exact_number("+977-9842536789"), "9842536789")
+        self.assertEqual(get_exact_number(""), "")
+        self.assertEqual(get_exact_number("test"), "test")
+        self.assertEqual(get_exact_number("977test"), "test")
+        self.assertEqual(get_exact_number("+977test"), "test")
+        self.assertEqual(get_exact_number("+977-test"), "test")
+        self.assertEqual(get_exact_number("+977-142314819"), "142314819")
+        self.assertEqual(get_exact_number("0154225639"), "0154225639")
+        self.assertEqual(get_exact_number("9770154225639"), "0154225639")
+        self.assertEqual(get_exact_number("0565114679"), "0565114679")
+        self.assertEqual(get_exact_number("984-2536789"), "9842536789")
+        self.assertEqual(get_exact_number("984-2536-789"), "9842536789")
+        with self.assertRaises(AttributeError):
+            get_exact_number(None)  # type: ignore
+
+
+class TestMobileNumberParser(unittest.TestCase):
+    def test__get_operator__with_invalid_input(self):
+        self.assertEqual(_get_operator("Hello there"), None)
+
+    def test__get_operator__with_not_matching_input(self):
+        self.assertEqual(_get_operator("9132536789"), None)
+
+    def test__get_operator__for_ntc(self):
+        self.assertEqual(_get_operator("9842536789"), Operator.NEPAL_TELECOM)
+        self.assertEqual(_get_operator("9852536789"), Operator.NEPAL_TELECOM)
+        self.assertEqual(_get_operator("9862536789"), Operator.NEPAL_TELECOM)
+        # For CDMA (Nepal Telecom)
+        self.assertEqual(_get_operator("9742536789"), Operator.NEPAL_TELECOM)
+        self.assertEqual(_get_operator("9752536789"), Operator.NEPAL_TELECOM)
+
+    def test__get_operator__for_ncell(self):
+        self.assertEqual(_get_operator("9802536789"), Operator.NCELL)
+        self.assertEqual(_get_operator("9812536789"), Operator.NCELL)
+        self.assertEqual(_get_operator("9822536789"), Operator.NCELL)
+
+    def test__get_operator__for_smart_cell(self):
+        self.assertEqual(_get_operator("9612536789"), Operator.SMART_CELL)
+        self.assertEqual(_get_operator("9622536789"), Operator.SMART_CELL)
+        self.assertEqual(_get_operator("9882536789"), Operator.SMART_CELL)
+
+    def test__get_operator__for_utl(self):
+        self.assertEqual(_get_operator("9722536789"), Operator.UTL)
+
+    def test__get_operator__for_hello_mobile(self):
+        self.assertEqual(_get_operator("9632536789"), Operator.HELLO_MOBILE)
+
+    @mock.patch("nepali.phone_number._get_operator", return_value="test")
+    def test__parse_mobile_number_returns_valid_data(self, *_):
+        data = _parse_mobile_number("+977-9842536789")
+        self.assertEqual(data and data["type"], "Mobile")
+        self.assertEqual(data and data["operator"], "test")
+        self.assertEqual(data and data["number"], "9842536789")
+
+    @mock.patch("nepali.phone_number._get_operator", return_value=None)
+    def test__parse_mobile_number_on_invalid_operator(self, *_):
+        data = _parse_mobile_number("+977-14231481")
+        self.assertEqual(data, None)
+
+
+class TestLandlineNumberParser(unittest.TestCase):
+    def test__get_area_code_for_kathmandu(self):
+        self.assertEqual(_get_area_code("0142314819"), "01")
+        self.assertEqual(_get_area_code("0154225639"), "01")
+
+    def test__get_area_code_for_biratnagar(self):
+        self.assertEqual(_get_area_code("021420431"), "021")
+
+    def test__get_area_code_for_chitwan(self):
+        self.assertEqual(_get_area_code("056520198"), "056")
+
+    def test__get_area_code_for_jhapa(self):
+        self.assertEqual(_get_area_code("023455125"), "023")
+
+    def test__get_area_code_for_rupandehi(self):
+        self.assertEqual(_get_area_code("071540029"), "071")
+
+    def test__get_area_code_for_kaski(self):
+        self.assertEqual(_get_area_code("061463076"), "061")
+
+    def test__get_area_code_for_dhading(self):
+        self.assertEqual(_get_area_code("010520133"), "010")
+
+    def test__get_area_code_for_syangja(self):
+        self.assertEqual(_get_area_code("063420211"), "063")
+
+    @mock.patch("nepali.phone_number._get_area_code", return_value="test")
+    def test__parse_landline_number_returns_valid_data(self, *_):
+        data = _parse_landline_number("0142314819")
+        self.assertEqual(data["type"], "Landline")
+        self.assertEqual(data["area_code"], "test")
+        self.assertEqual(data["number"], "0142314819")
+
+    @mock.patch("nepali.phone_number._get_area_code", return_value="test")
+    def test__parse_landline_number_returns_valid_data_for_977(self, *_):
+        data = _parse_landline_number("+977142314819")
+        self.assertEqual(data["type"], "Landline")
+        self.assertEqual(data["area_code"], "test")
+        self.assertEqual(data["number"], "0142314819")
+
+
+class TestParser(unittest.TestCase):
+    def test_none_number_returns_none(self):
+        self.assertEqual(parse(None), None)  # type: ignore
+
+    def test_empty_number_returns_none(self):
+        self.assertEqual(parse(""), None)
+
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=True)
+    @mock.patch("nepali.phone_number._parse_mobile_number", return_value="Mobile")
+    def test_mobile_number_parsing(self, *_):
+        self.assertEqual(parse("number"), "Mobile")
+
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=False)
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=True)
+    @mock.patch("nepali.phone_number._parse_landline_number", return_value="Landline")
+    def test_landline_number_parsing(self, *_):
+        self.assertEqual(parse("number"), "Landline")
+
+    @mock.patch("nepali.phone_number.is_mobile_number", return_value=False)
+    @mock.patch("nepali.phone_number.is_landline_number", return_value=False)
+    def test_invalid_number_returns_none(self, *_):
+        self.assertEqual(parse("number"), None)
+
+
+class TestParseIntegration(unittest.TestCase):
+    def test_parse_for_mobile_number(self):
+        data = parse("+9779842536789")
+        self.assertEqual(data and data["type"], "Mobile")
+        self.assertEqual(data and data["number"], "9842536789")
+        self.assertEqual(data and data["operator"], Operator.NEPAL_TELECOM)
+
+    def test_parse_for_landline_number(self):
+        data = parse("+977-142314819")
+        self.assertEqual(data and data["type"], "Landline")
+        self.assertEqual(data and data["number"], "0142314819")
+        self.assertEqual(data and data["area_code"], "01")

nepali/tests/test_timezone.py

@@ -0,0 +1,192 @@
+"""
+To run only this unit test use the command below.
+
+    python -m unittest nepali/tests/test_timezone.py -v
+"""
+import datetime
+import unittest
+from unittest.mock import patch
+
+from nepali.constants import NEPAL_TIMEZONE
+from nepali.timezone import (
+    NepaliTimeZone,
+    get_timezone,
+    now,
+    to_nepali_timezone,
+    to_utc_timezone,
+    utc_now,
+)
+
+
+class TestNepaliTimeZone(unittest.TestCase):
+    def setUp(self):
+        self.nepali_timezone = NepaliTimeZone()
+        return super().setUp()
+
+    def test_nepali_timezone_dst(self):
+        self.assertEqual(self.nepali_timezone.dst(None), datetime.timedelta(0))
+
+    def test_nepali_timezone_utcoffset(self):
+        self.assertEqual(
+            self.nepali_timezone.utcoffset(None),
+            datetime.timedelta(hours=5, minutes=45),
+        )
+
+    def test_nepali_timezone_tzname(self):
+        self.assertEqual(self.nepali_timezone.tzname(None), NEPAL_TIMEZONE)
+
+    def test_nepali_timezone_str(self):
+        self.assertEqual(str(self.nepali_timezone), NEPAL_TIMEZONE)
+
+    def test_nepali_timezone_repr(self):
+        self.assertEqual(repr(self.nepali_timezone), NEPAL_TIMEZONE)
+
+    def test_datetime_with_nepali_timezone(self):
+        dt = datetime.datetime(2015, 10, 14, tzinfo=self.nepali_timezone)
+        self.assertEqual(dt.tzinfo, self.nepali_timezone)
+        self.assertEqual(dt.tzname(), self.nepali_timezone.tzname(dt))
+        self.assertEqual(dt.utcoffset(), self.nepali_timezone.utcoffset(dt))
+
+
+class TestTimezoneUtils(unittest.TestCase):
+    def test_get_timezone(self):
+        tz = get_timezone()
+        self.assertIsNotNone(tz)
+
+    @patch("nepali.timezone.get_timezone")
+    @patch("nepali.timezone.datetime")
+    def test_timezone_now(self, mock_datetime, mock_get_timezone):
+        # mocking data
+        mock_get_timezone.return_value = (
+            datetime.timezone.utc
+        )  # mocking get_timezone => UTC
+        datetime_now = mock_datetime.datetime.now
+        datetime_now.return_value = datetime.datetime(
+            2015, 1, 1
+        )  # mocking datetime.now => 2015/1/1
+
+        # calling now
+        current_dt = now()
+
+        # checking
+        self.assertEqual(current_dt, datetime.datetime(2015, 1, 1))
+        self.assertSequenceEqual(datetime_now.call_args[0], [datetime.timezone.utc])
+
+    @patch("nepali.timezone.datetime")
+    def test_timezone_utc_now(self, mock_datetime):
+        # mocking data
+        mock_datetime.timezone.utc = (
+            datetime.timezone.utc
+        )  # reverting the utc timezone mock
+        datetime_now = mock_datetime.datetime.now
+        datetime_now.return_value = datetime.datetime(
+            2015, 1, 1
+        )  # mocking datetime.now => 2015/1/1
+
+        # calling utc_now
+        utc_dt = utc_now()
+
+        # checking
+        self.assertEqual(utc_dt, datetime.datetime(2015, 1, 1))
+        self.assertSequenceEqual(datetime_now.call_args[0], [datetime.timezone.utc])
+
+    # to_utc_timezone
+    def test_to_utc_timezone_invalid_input_returns_as_it_is(self):
+        self.assertEqual(to_utc_timezone("test"), "test")  # type: ignore
+
+    @patch("nepali.timezone.get_timezone")
+    def test_to_utc_timezone_without_timezone(self, mock_get_timezone):
+        mock_get_timezone.return_value = datetime.timezone(
+            offset=datetime.timedelta(hours=5, minutes=30)
+        )  # Indian timezone
+        dt = datetime.datetime(2014, 11, 14, 10, 15, 11)
+        utc_dt = to_utc_timezone(dt)
+        self.assertEqual(utc_dt.tzinfo, datetime.timezone.utc)
+        self.assertSequenceEqual(
+            (
+                utc_dt.year,
+                utc_dt.month,
+                utc_dt.day,
+                utc_dt.hour,
+                utc_dt.minute,
+                utc_dt.second,
+            ),
+            (2014, 11, 14, 4, 45, 11),
+        )
+
+    def test_to_utc_timezone_with_utc_timezone(self):
+        dt = datetime.datetime(2014, 11, 14, 10, 15, 11, tzinfo=datetime.timezone.utc)
+        utc_dt = to_utc_timezone(dt)
+        self.assertEqual(utc_dt.tzinfo, datetime.timezone.utc)
+        self.assertSequenceEqual(
+            (
+                utc_dt.year,
+                utc_dt.month,
+                utc_dt.day,
+                utc_dt.hour,
+                utc_dt.minute,
+                utc_dt.second,
+            ),
+            (2014, 11, 14, 10, 15, 11),
+        )
+
+    def test_to_utc_timezone_with_nepali_timezone(self):
+        dt = datetime.datetime(2014, 11, 14, 10, 15, 11, tzinfo=NepaliTimeZone())
+        utc_dt = to_utc_timezone(dt)
+        self.assertEqual(utc_dt.tzinfo, datetime.timezone.utc)
+        self.assertSequenceEqual(
+            (
+                utc_dt.year,
+                utc_dt.month,
+                utc_dt.day,
+                utc_dt.hour,
+                utc_dt.minute,
+                utc_dt.second,
+            ),
+            (2014, 11, 14, 4, 30, 11),
+        )
+
+    # to_nepali_timezone
+    def test_to_nepali_timezone_invalid_input_returns_as_it_is(self):
+        self.assertEqual(to_nepali_timezone("test"), "test")  # type: ignore
+
+    def test_to_nepali_timezone_without_timezone(self):
+        dt = datetime.datetime(2014, 11, 14, 10, 15, 11)
+        nepali_dt = to_nepali_timezone(dt)
+        self.assertEqual(nepali_dt.tzinfo, NepaliTimeZone())
+        self.assertSequenceEqual(
+            (dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second),
+            (2014, 11, 14, 10, 15, 11),
+        )
+
+    def test_to_nepali_timezone_with_utc_timezone(self):
+        dt = datetime.datetime(2014, 11, 14, 4, 30, 11, tzinfo=datetime.timezone.utc)
+        nepali_dt = to_nepali_timezone(dt)
+        self.assertEqual(nepali_dt.tzinfo, NepaliTimeZone())
+        self.assertSequenceEqual(
+            (
+                nepali_dt.year,
+                nepali_dt.month,
+                nepali_dt.day,
+                nepali_dt.hour,
+                nepali_dt.minute,
+                nepali_dt.second,
+            ),
+            (2014, 11, 14, 10, 15, 11),
+        )
+
+    def test_to_nepali_timezone_with_nepali_timezone(self):
+        dt = datetime.datetime(2014, 11, 14, 10, 15, 11, tzinfo=NepaliTimeZone())
+        nepali_dt = to_nepali_timezone(dt)
+        self.assertEqual(nepali_dt.tzinfo, NepaliTimeZone())
+        self.assertSequenceEqual(
+            (
+                nepali_dt.year,
+                nepali_dt.month,
+                nepali_dt.day,
+                nepali_dt.hour,
+                nepali_dt.minute,
+                nepali_dt.second,
+            ),
+            (2014, 11, 14, 10, 15, 11),
+        )