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

nepali/tests/test_datetime.py

@@ -1,32 +1,112 @@
 import datetime
 import unittest
 
-from nepali.datetime import nepalidate, nepalitime, nepalidatetime
+from nepali.datetime import nepalidate, nepalidatetime, nepalitime
+from nepali.datetime.utils import to_nepalidate, to_nepalidatetime
+from nepali.exceptions import InvalidNepaliDateTimeObjectException
 from nepali.timezone import NepaliTimeZone
-from nepali.utils import to_nepali_timezone
 
-class TestNepaliDateTime(unittest.TestCase):
 
+class TestNepaliDateTime(unittest.TestCase):
     #
     # nepalidate
 
     def test_nepalidate_now_and_today(self):
         today = nepalidate.today()
         now = nepalidate.now()
-        self.assertEqual(today, now, msg='nepalidate today is not equals to now.')
+        self.assertEqual(today, now, msg="nepalidate today is not equals to now.")
 
-    def test_nepalidate_comparision(self):
+    def test_nepalidate_comparison(self):
         nepalidate_obj1 = nepalidate(year=2051, month=4, day=28)
 
         # test equal date
         nepalidate_obj2 = nepalidate(year=2051, month=4, day=28)
-        self.assertEqual(nepalidate_obj1, nepalidate_obj2, 'Same nepali date are not checked equals.')
+        self.assertEqual(
+            nepalidate_obj1, nepalidate_obj2, "Same nepali date are not checked equals."
+        )
 
         # test different date
         nepalidate_obj3 = nepalidate(year=2051, month=4, day=29)
-        self.assertNotEqual(nepalidate_obj1, nepalidate_obj3, 'Different nepali date are checked as equal.')
+        self.assertNotEqual(
+            nepalidate_obj1,
+            nepalidate_obj3,
+            "Different nepali date are checked as equal.",
+        )
+
+        #
+        # test addition
+
+        # test with timedelta
+        nt = nepalidate(year=2051, month=4, day=29)
+        nt = nt + datetime.timedelta(days=1)
+        self.assertEqual((nt.year, nt.month, nt.day), (2051, 4, 30))
+
+        # test without timedelta
+        with self.assertRaises(TypeError):
+            nt = nt + 1
+
+        #
+        # test subtraction
+
+        # test with nepali date
+        td = nepalidate(year=2051, month=4, day=30) - nepalidate(
+            year=2051, month=4, day=29
+        )
+        self.assertEqual(td.days, 1)
+
+        # test with python date
+        td = nepalidate(year=2051, month=4, day=30) - datetime.date(
+            year=1994, month=8, day=13
+        )
+        self.assertEqual(td.days, 1)
+
+        # test with timedelta
+        nt = nepalidate(year=2051, month=4, day=30) - datetime.timedelta(days=1)
+        self.assertEqual((nt.year, nt.month, nt.day), (2051, 4, 29))
+
+        # test without timedelta
+        with self.assertRaises(TypeError):
+            nt = nt - 1
+
+        #
+        # test less than
+        self.assertEqual(nepalidate(2051, 4, 29) < nepalidate(2051, 4, 30), True)
+        self.assertEqual(nepalidate(2051, 4, 29) < nepalidate(2051, 4, 29), False)
+        self.assertEqual(nepalidate(2051, 4, 29) < datetime.date(1994, 8, 14), True)
+        self.assertEqual(nepalidate(2051, 4, 29) < datetime.date(1994, 8, 13), False)
+        with self.assertRaises(TypeError):
+            _ = nepalidate(2051, 4, 29) < 0
+
+        #
+        # test less than equal
+        self.assertEqual(nepalidate(2051, 4, 29) <= nepalidate(2051, 4, 30), True)
+        self.assertEqual(nepalidate(2051, 4, 29) <= nepalidate(2051, 4, 29), True)
+        self.assertEqual(nepalidate(2051, 4, 30) <= nepalidate(2051, 4, 29), False)
+        self.assertEqual(nepalidate(2051, 4, 29) <= datetime.date(1994, 8, 14), True)
+        self.assertEqual(nepalidate(2051, 4, 29) <= datetime.date(1994, 8, 13), True)
+        self.assertEqual(nepalidate(2051, 4, 30) <= datetime.date(1994, 8, 13), False)
+        with self.assertRaises(TypeError):
+            _ = nepalidate(2051, 4, 29) <= 0
+
+        #
+        # test greater than
+        self.assertEqual(nepalidate(2051, 4, 30) > nepalidate(2051, 4, 29), True)
+        self.assertEqual(nepalidate(2051, 4, 30) > nepalidate(2051, 4, 30), False)
+        self.assertEqual(nepalidate(2051, 4, 30) > datetime.date(1994, 8, 14), False)
+        self.assertEqual(nepalidate(2051, 4, 30) > datetime.date(1994, 8, 13), True)
+        with self.assertRaises(TypeError):
+            _ = nepalidate(2051, 4, 29) > 0
 
-        # TODO: check other comparisions (later)
+        #
+        # test greater than equal
+        self.assertEqual(nepalidate(2051, 4, 30) >= nepalidate(2051, 4, 30), True)
+        self.assertEqual(nepalidate(2051, 4, 30) >= nepalidate(2051, 4, 29), True)
+        self.assertEqual(nepalidate(2051, 4, 29) >= nepalidate(2051, 4, 30), False)
+        self.assertEqual(nepalidate(2051, 4, 30) >= datetime.date(1994, 8, 14), True)
+        self.assertEqual(nepalidate(2051, 4, 30) >= datetime.date(1994, 8, 13), True)
+        self.assertEqual(nepalidate(2051, 4, 29) >= datetime.date(1994, 8, 14), False)
+        with self.assertRaises(TypeError):
+            _ = nepalidate(2051, 4, 29) >= 0
 
     def test_nepalidate_year_month_day(self):
         nepalidate_obj = nepalidate(year=2051, month=4, day=28)
@@ -38,29 +118,50 @@ class TestNepaliDateTime(unittest.TestCase):
     def test_nepalidate_from_date(self):
         python_date_obj = datetime.date(year=1994, month=8, day=12)
         nepalidate_obj = nepalidate.from_date(python_date_obj)
-        self.assertEqual(python_date_obj, nepalidate_obj.to_date(), 'nepalidate from_date and to_date are not equal.')
+        self.assertEqual(
+            python_date_obj,
+            nepalidate_obj.to_date(),
+            "nepalidate from_date and to_date are not equal.",
+        )
 
     def test_nepalidate_from_datetime(self):
-        python_datetime_obj = datetime.datetime(year=1994, month=8, day=12, hour=4, minute=8, second=12)
+        python_datetime_obj = datetime.datetime(
+            year=1994, month=8, day=12, hour=4, minute=8, second=12
+        )
         nepalidate_obj = nepalidate.from_datetime(python_datetime_obj)
-        self.assertEqual(python_datetime_obj.date(), nepalidate_obj.to_date(), 'nepalidate from_datetime and to_datetime are not equal.')
+        self.assertEqual(
+            python_datetime_obj.date(),
+            nepalidate_obj.to_date(),
+            "nepalidate from_datetime and to_datetime are not equal.",
+        )
 
     def test_nepalidate_strftime(self):
         nepalidate_obj = nepalidate(year=2051, month=4, day=28)
-        self.assertEqual(nepalidate_obj.strftime('%Y-%m-%d'), '२०५१-०४-२८')
-        self.assertEqual(nepalidate_obj.strftime('%a %A %w %d %b %B %m %y %Y'), 'शुक्र शुक्रबार ५ २८ साउन साउन ०४ ५१ २०५१')
-        self.assertEqual(nepalidate_obj.strftime_en('%Y-%m-%d'), '2051-04-28')
-        self.assertEqual(nepalidate_obj.strftime_en('%a %A %w %d %b %B %m %y %Y'), 'Fri Friday 5 28 Sharwan Sharwan 04 51 2051')
+        self.assertEqual(nepalidate_obj.strftime("%Y-%m-%d"), "2051-04-28")
+        self.assertEqual(
+            nepalidate_obj.strftime("%a %A %w %d %b %B %m %y %Y"),
+            "Fri Friday 5 28 Sharwan Sharwan 04 51 2051",
+        )
+        self.assertEqual(nepalidate_obj.strftime_en("%Y-%m-%d"), "2051-04-28")
+        self.assertEqual(
+            nepalidate_obj.strftime_en("%a %A %w %d %b %B %m %y %Y"),
+            "Fri Friday 5 28 Sharwan Sharwan 04 51 2051",
+        )
+        self.assertEqual(nepalidate_obj.strftime_ne("%Y-%m-%d"), "२०५१-०४-२८")
+        self.assertEqual(
+            nepalidate_obj.strftime_ne("%a %A %w %d %b %B %m %y %Y"),
+            "शुक्र शुक्रबार ५ २८ साउन साउन ०४ ५१ २०५१",
+        )
 
     def test_nepalidate_strptime(self):
-        nepalidatetime_obj = nepalidate.strptime('2078-01-12', format='%Y-%m-%d')
+        nepalidatetime_obj = nepalidate.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)
 
     #
     # nepalitime
-    
+
     def test_nepalitime_now(self):
         nepalitime_obj, dt_now = nepalitime.now(), datetime.datetime.now()
         self.assertEqual(nepalitime_obj.hour, dt_now.hour)
@@ -71,24 +172,67 @@ class TestNepaliDateTime(unittest.TestCase):
     # nepalidatetime
 
     def test_nepalidatetime_from_date(self):
-        python_datetime_obj = datetime.datetime(year=1994, month=8, day=12, hour=5, minute=28, second=23)
+        python_datetime_obj = datetime.datetime(
+            year=1994, month=8, day=12, hour=5, minute=28, second=23
+        )
         nepalidatetime_obj = nepalidatetime.from_date(python_datetime_obj)
         self.assertEqual(python_datetime_obj.date(), nepalidatetime_obj.to_date())
 
     def test_nepalidatetime_from_datetime(self):
-        python_datetime_obj = datetime.datetime(year=1994, month=8, day=12, hour=5, minute=28, second=23, tzinfo=NepaliTimeZone())
+        python_datetime_obj = datetime.datetime(
+            year=1994,
+            month=8,
+            day=12,
+            hour=5,
+            minute=28,
+            second=23,
+            tzinfo=NepaliTimeZone(),
+        )
         nepalidatetime_obj = nepalidatetime.from_datetime(python_datetime_obj)
-        self.assertEqual(python_datetime_obj, nepalidatetime_obj.to_datetime(), msg="{} and {} are not equal.".format(python_datetime_obj, nepalidatetime_obj.to_datetime()))
+        self.assertEqual(
+            python_datetime_obj,
+            nepalidatetime_obj.to_datetime(),
+            msg="{} and {} are not equal.".format(
+                python_datetime_obj, nepalidatetime_obj.to_datetime()
+            ),
+        )
 
     def test_nepalidatetime_strftime(self):
-        nepalidatetime_obj = nepalidatetime(year=2051, month=4, day=28, hour=5, minute=28, second=23)
-        self.assertEqual(nepalidatetime_obj.strftime('%Y-%m-%d %H:%M:%S'), '२०५१-०४-२८ ०५:२८:२३')
-        self.assertEqual(nepalidatetime_obj.strftime('%a %A %w %d %b %B %m %y %Y %H %I %p %M %S'), 'शुक्र शुक्रबार ५ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३')
-        self.assertEqual(nepalidatetime_obj.strftime_en('%Y-%m-%d %H:%M:%S'), '2051-04-28 05:28:23')
-        self.assertEqual(nepalidatetime_obj.strftime_en('%a %A %w %d %b %B %m %y %Y %H %I %p %M %S'), 'Fri Friday 5 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23')
+        nepalidatetime_obj = nepalidatetime(
+            year=2051, month=4, day=28, hour=5, minute=28, second=23
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime("%Y-%m-%d %H:%M:%S"), "2051-04-28 05:28:23"
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime("%a %A %w %d %b %B %m %y %Y %H %I %p %M %S"),
+            "Fri Friday 5 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23",
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime_en("%Y-%m-%d %H:%M:%S"), "2051-04-28 05:28:23"
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime_en("%a %A %w %d %b %B %m %y %Y %H %I %p %M %S"),
+            "Fri Friday 5 28 Sharwan Sharwan 04 51 2051 05 05 AM 28 23",
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime_en(
+                "%a %A %w %d %-d %b %B %m %-m %y %Y %H %-H %I %-I %p %M %-M %S %-S %%"
+            ),
+            "Fri Friday 5 28 28 Sharwan Sharwan 04 4 51 2051 05 5 05 5 AM 28 28 23 23 %",
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime_ne("%Y-%m-%d %H:%M:%S"), "२०५१-०४-२८ ०५:२८:२३"
+        )
+        self.assertEqual(
+            nepalidatetime_obj.strftime_ne("%a %A %w %d %b %B %m %y %Y %H %I %p %M %S"),
+            "शुक्र शुक्रबार ५ २८ साउन साउन ०४ ५१ २०५१ ०५ ०५ शुभप्रभात २८ २३",
+        )
 
     def test_nepalidatetime_strptime(self):
-        nepalidatetime_obj = nepalidatetime.strptime('2078-01-12 13:12', format='%Y-%m-%d %H:%M')
+        nepalidatetime_obj = nepalidatetime.strptime(
+            "2078-01-12 13:12", format="%Y-%m-%d %H:%M"
+        )
         self.assertEqual(nepalidatetime_obj.year, 2078)
         self.assertEqual(nepalidatetime_obj.month, 1)
         self.assertEqual(nepalidatetime_obj.day, 12)
@@ -96,7 +240,109 @@ class TestNepaliDateTime(unittest.TestCase):
         self.assertEqual(nepalidatetime_obj.minute, 12)
 
     def test_nepalidatetime_timedelta(self):
-        nepalidatetime_obj1 = nepalidatetime(year=2051, month=4, day=28, hour=5, minute=28, second=23)
-        nepalidatetime_obj2 = nepalidatetime(year=2051, month=4, day=29, hour=5, minute=28, second=23)
+        nepalidatetime_obj1 = nepalidatetime(
+            year=2051, month=4, day=28, hour=5, minute=28, second=23
+        )
+        nepalidatetime_obj2 = nepalidatetime(
+            year=2051, month=4, day=29, hour=5, minute=28, second=23
+        )
         nepalidatetime_obj1 = nepalidatetime_obj1 + datetime.timedelta(days=1)
-        self.assertEqual(nepalidatetime_obj1, nepalidatetime_obj2, msg='{} and {} are not equal'.format(nepalidatetime_obj1, nepalidatetime_obj2))
+        self.assertEqual(
+            nepalidatetime_obj1,
+            nepalidatetime_obj2,
+            msg=f"{nepalidatetime_obj1} and {nepalidatetime_obj2} are not equal",
+        )
+
+
+class TestDatetimeUtils(unittest.TestCase):
+    # to_nepalidate
+    def test_to_nepalidate_raises_exception_on_invalid_input(self):
+        with self.assertRaises(InvalidNepaliDateTimeObjectException):
+            to_nepalidate("Invalid input")
+
+    def test_to_nepalidate_from_python_date(self):
+        np_date = to_nepalidate(datetime.date(2023, 2, 26))
+        self.assertSequenceEqual(
+            (np_date.year, np_date.month, np_date.day), (2079, 11, 14)
+        )
+
+    def test_to_nepalidate_from_python_datetime(self):
+        np_date = to_nepalidate(datetime.datetime(2023, 2, 26, 1, 12, 13))
+        self.assertSequenceEqual(
+            (np_date.year, np_date.month, np_date.day), (2079, 11, 14)
+        )
+
+    def test_to_nepalidate_from_nepalidate(self):
+        np_date = to_nepalidate(nepalidate(2079, 11, 14))
+        self.assertSequenceEqual(
+            (np_date.year, np_date.month, np_date.day), (2079, 11, 14)
+        )
+
+    def test_to_nepalidate_from_nepalidatetime(self):
+        np_date = to_nepalidate(nepalidatetime(2079, 11, 14, 1, 12, 13))
+        self.assertSequenceEqual(
+            (np_date.year, np_date.month, np_date.day), (2079, 11, 14)
+        )
+
+    # to_nepalidatetime
+    def test_to_nepalidatetime_raises_exception_on_invalid_input(self):
+        with self.assertRaises(InvalidNepaliDateTimeObjectException):
+            to_nepalidatetime("Invalid input")
+
+    def test_to_nepalidatetime_from_python_date(self):
+        np_date = to_nepalidatetime(datetime.date(2023, 2, 26))
+        self.assertSequenceEqual(
+            (
+                np_date.year,
+                np_date.month,
+                np_date.day,
+                np_date.hour,
+                np_date.minute,
+                np_date.second,
+            ),
+            (2079, 11, 14, 0, 0, 0),
+        )
+
+    def test_to_nepalidatetime_from_python_datetime(self):
+        np_date = to_nepalidatetime(
+            datetime.datetime(2023, 2, 26, 4, 30, 13, tzinfo=datetime.timezone.utc)
+        )
+        self.assertSequenceEqual(
+            (
+                np_date.year,
+                np_date.month,
+                np_date.day,
+                np_date.hour,
+                np_date.minute,
+                np_date.second,
+            ),
+            (2079, 11, 14, 10, 15, 13),
+        )
+
+    def test_to_nepalidatetime_from_nepalidate(self):
+        np_date = to_nepalidatetime(nepalidate(2079, 11, 14))
+        self.assertSequenceEqual(
+            (
+                np_date.year,
+                np_date.month,
+                np_date.day,
+                np_date.hour,
+                np_date.minute,
+                np_date.second,
+            ),
+            (2079, 11, 14, 0, 0, 0),
+        )
+
+    def test_to_nepalidatetime_from_nepalidatetime(self):
+        np_date = to_nepalidatetime(nepalidatetime(2079, 11, 14, 1, 12, 13))
+        self.assertSequenceEqual(
+            (
+                np_date.year,
+                np_date.month,
+                np_date.day,
+                np_date.hour,
+                np_date.minute,
+                np_date.second,
+            ),
+            (2079, 11, 14, 1, 12, 13),
+        )

nepali/tests/test_humanize.py

@@ -1,13 +1,84 @@
 import datetime
 import unittest
+from unittest.mock import patch
 
-from nepali.datetime import nepalihumanize
+from nepali.datetime import HumanizeDateTime, nepalidate, nepalidatetime, nepalihumanize
+from nepali.exceptions import InvalidNepaliDateTimeObjectException
+from nepali.timezone import NepaliTimeZone
 
-class TestNepaliDateTime(unittest.TestCase):
+REF_TIME = datetime.datetime(2015, 1, 1, 10, 15, tzinfo=NepaliTimeZone())
 
-    def test_nepalihumanize_basic(self):
-        humanize_str = nepalihumanize(datetime.datetime(2022, 2, 15), threshold=0)
-        self.assertNotEqual(humanize_str, None, msg='Invalid nepali humanize str.')
 
-        humanize_str = nepalihumanize(datetime.datetime(2022, 2, 15), threshold=600000000)
-        self.assertNotEqual(humanize_str, None, msg='Invalid nepali humanize str with threshold.')
+@patch("nepali.datetime._humanize.now", return_value=REF_TIME)
+class TestNepaliHumanizeFunction(unittest.TestCase):
+    def test_nepalihumanize_for_just_now(self, *_):
+        humanize_str = nepalihumanize(REF_TIME)
+        self.assertEqual(humanize_str, "भर्खरै")
+
+    def test_nepalihumanize_for_seconds(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(seconds=10))
+        self.assertEqual(humanize_str, "१० सेकेन्ड अघि")
+
+    def test_nepalihumanize_for_minutes(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(minutes=10))
+        self.assertEqual(humanize_str, "१० मिनेट अघि")
+
+    def test_nepalihumanize_for_hours(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(hours=10))
+        self.assertEqual(humanize_str, "१० घण्टा अघि")
+
+    def test_nepalihumanize_for_days(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(days=10))
+        self.assertEqual(humanize_str, "१० दिन अघि")
+
+    def test_nepalihumanize_for_months(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(days=32))
+        self.assertEqual(humanize_str, "१ महिना अघि")
+
+    def test_nepalihumanize_for_years(self, *_):
+        humanize_str = nepalihumanize(REF_TIME - datetime.timedelta(days=366))
+        self.assertEqual(humanize_str, "१ वर्ष अघि")
+
+    def test_nepalihumanize_for_future(self, *_):
+        humanize_str = nepalihumanize(REF_TIME + datetime.timedelta(days=10))
+        self.assertEqual(humanize_str, "१० दिन पछि")
+
+    def test_nepalihumanize_returns_date_after_threshold(self, *_):
+        humanize_str = nepalihumanize(
+            REF_TIME - datetime.timedelta(seconds=10), threshold=10
+        )
+        self.assertEqual(humanize_str, "पुस १७, २०७१")
+
+
+class TestHumanizeDateTimeClass(unittest.TestCase):
+    def test_nepali_humanize_raise_exception_on_invalid_input(self, *_):
+        with self.assertRaises(InvalidNepaliDateTimeObjectException):
+            HumanizeDateTime("test")
+
+        with self.assertRaises(InvalidNepaliDateTimeObjectException):
+            HumanizeDateTime(None)
+
+        with self.assertRaises(InvalidNepaliDateTimeObjectException):
+            HumanizeDateTime("2017-12-04")
+
+    def test_nepali_humanize_supports_python_date(self, *_):
+        humanize_obj = HumanizeDateTime(datetime.date.today())
+        self.assertEqual(type(humanize_obj.to_str()), str)
+
+    def test_nepali_humanize_supports_python_datetime(self, *_):
+        humanize_obj = HumanizeDateTime(datetime.datetime.now())
+        self.assertEqual(type(humanize_obj.to_str()), str)
+
+    def test_nepali_humanize_supports_nepalidate(self, *_):
+        humanize_obj = HumanizeDateTime(nepalidate.today())
+        self.assertEqual(type(humanize_obj.to_str()), str)
+
+    def test_nepali_humanize_supports_nepalidatetime(self, *_):
+        humanize_obj = HumanizeDateTime(nepalidatetime.now())
+        self.assertEqual(type(humanize_obj.to_str()), str)
+
+    @patch("nepali.datetime._humanize.now", return_value=REF_TIME)
+    def test_test_nepali_humanize_str_and_repr(self, *_):
+        humanize_obj = HumanizeDateTime(REF_TIME + datetime.timedelta(days=10))
+        self.assertEqual(str(humanize_obj), "१० दिन पछि")
+        self.assertEqual(repr(humanize_obj), "१० दिन पछि")

nepali/tests/test_locations.py

@@ -0,0 +1,154 @@
+import unittest
+
+from nepali import locations
+from nepali.locations.models import (
+    District,
+    Location,
+    Municipality,
+    MunicipalityType,
+    Province,
+)
+from nepali.locations.utils import (
+    _filter_location,
+    get_district,
+    get_municipality,
+    get_province,
+)
+
+
+class TestLocations(unittest.TestCase):
+    def test_locations_count(self):
+        self.assertEqual(len(locations.provinces), 7)
+        self.assertEqual(len(locations.districts), 77)
+        self.assertEqual(len(locations.municipalities), 753)
+
+    def test_utils_filter_location(self):
+        # checking if no argument is passed
+        with self.assertRaises(ValueError):
+            _filter_location(locations=locations.provinces)
+
+        # checking pattern match
+        province = _filter_location(locations=locations.provinces, name="Bagmati")
+        self.assertEqual(province.name, "Bagmati Province")
+
+        # checking ignore-case match
+        province = _filter_location(locations=locations.provinces, name="bagmati")
+        self.assertEqual(province.name, "Bagmati Province")
+
+        # checking with invalid name
+        province = _filter_location(locations=locations.provinces, name="invalid")
+        self.assertEqual(province, None)
+
+        # checking using exact True with invalid match
+        province = _filter_location(
+            locations=locations.provinces, name="Bagmati", exact=True
+        )
+        self.assertEqual(province, None)
+
+        # checking using exact True with a valid match
+        province = _filter_location(
+            locations=locations.provinces, name="Bagmati Province", exact=True
+        )
+        self.assertEqual(province.name, "Bagmati Province")
+
+        # checking assertion if exact and multiple is passes together
+        with self.assertRaises(ValueError):
+            _filter_location(
+                locations=locations.provinces,
+                name="Bagmati Province",
+                exact=True,
+                multiple=True,
+            )
+
+        # checking multiple value match
+        provinces = _filter_location(
+            locations=locations.provinces, name="Province", multiple=True
+        )
+        self.assertEqual(type(provinces), list)
+        self.assertEqual(len(provinces), 7)
+
+        # checking multiple value with invalid match
+        provinces = _filter_location(
+            locations=locations.provinces, name="invalid", multiple=True
+        )
+        self.assertEqual(len(provinces), 0)
+
+        # checking pattern match with nepali name
+        province = _filter_location(locations=locations.provinces, name_nepali="बागमती")
+        self.assertEqual(province.name_nepali, "बागमती प्रदेश")
+
+        # checking using exact True with a valid nepali match
+        province = _filter_location(
+            locations=locations.provinces, name_nepali="बागमती प्रदेश", exact=True
+        )
+        self.assertEqual(province.name_nepali, "बागमती प्रदेश")
+
+
+class TestLocationsUtils(unittest.TestCase):
+    def test_utils_get_province(self):
+        province = get_province(name="Bagmati")
+        self.assertEqual(province.name, "Bagmati Province")
+
+    def test_utils_get_district(self):
+        district = get_district(name="Kathmandu")
+        self.assertEqual(district.name, "Kathmandu")
+
+    def test_utils_get_municipality(self):
+        municipality = get_municipality(name="Kathmandu")
+        self.assertEqual(municipality.name, "Kathmandu Metropolitan City")
+
+
+class TestLocationsModels(unittest.TestCase):
+    def test_location_data(self):
+        location = Location("test_en", "test_ne")
+        self.assertEqual(location.name, "test_en")
+        self.assertEqual(location.name_nepali, "test_ne")
+
+    def test_location_str(self):
+        location = Location("test_en", "test_ne")
+        self.assertEqual(str(location), "test_en")
+
+    def test_location_repr(self):
+        location = Location("test_en", "test_ne")
+        self.assertEqual(repr(location), "test_en")
+
+    def test_districts_from_province(self):
+        province = Province("Province1", "Province1")
+        district = District(province, "District1", "District1")
+        self.assertListEqual(province.districts, [district])
+
+    def test_municipalities_from_province_and_district(self):
+        province = Province("Province1", "Province1")
+        district = District(province, "District1", "District1")
+        municipality = Municipality(
+            district, "Municipality1", "Municipality1", MunicipalityType.METROPOLITAN
+        )
+        self.assertListEqual(province.municipalities, [municipality])
+        self.assertListEqual(district.municipalities, [municipality])
+
+    def test_municipality_province_district_and_type(self):
+        province = Province("Province1", "Province1")
+        district = District(province, "District1", "District1")
+        municipality = Municipality(
+            district, "Municipality1", "Municipality1", MunicipalityType.METROPOLITAN
+        )
+        self.assertEqual(municipality.province, province)
+        self.assertEqual(municipality.district, district)
+        self.assertEqual(municipality.municipality_type, MunicipalityType.METROPOLITAN)
+
+    # MunicipalityType
+    def test_municipality_type_with_invalid_data(self):
+        with self.assertRaises(ValueError):
+            MunicipalityType("Hello")
+
+    def test_municipality_type_with_valid_data(self):
+        municipality_type = MunicipalityType("Metropolitan City")
+        self.assertEqual(municipality_type, MunicipalityType.METROPOLITAN)
+
+    def test_municipality_type_str(self):
+        municipality_type = MunicipalityType.RURAL_MUNICIPALITY
+        self.assertEqual(str(municipality_type), municipality_type.value)
+
+    def test_municipality_type_repr(self):
+        municipality_type = MunicipalityType.SUB_METROPOLITAN
+        self.assertEqual(repr(municipality_type), municipality_type.value)