gcivil-nyu-org / INET-Wednesday-Spring2024-Team-2 / 638

Committed 01 May 2024 07:15PM UTC coverage: 85.085% (+1.1%) from 83.958%

Build # 638

Build Type

Pull #182

travis-pro

Committed by

web-flow

Commit Message

Merge 3bef72187 into a04204438

Pull Request Pull Request #182: add tests

Run Details

15 of 43 new or added lines in 1 file covered. (34.88%)

530 existing lines in 18 files now uncovered.

1101 of 1294 relevant lines covered (85.09%)

1.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.17

/users/tests.py

from django.test import TestCase, SimpleTestCase, Client, RequestFactory
from django.urls import reverse

from .forms import User, UserSignUpForm, LandlordSignupForm, RentalListingForm
from .models import CustomUser, Rental_Listings, Favorite
from django.contrib.messages import get_messages
from datetime import date, timedelta
from django.core.files.uploadedfile import SimpleUploadedFile
from django.utils import timezone
import json
import os
import sys
import unittest
from unittest.mock import patch, MagicMock
from .views import landlord_profile_update, map_view, profile_view_edit, apply_filters
from .forms import User, UserSignUpForm, CustomUserEditForm
from .models import CustomUser, Rental_Listings
from .views import map_view, add_rental_listing


class CustomUserModelTests(TestCase):
    def test_create_user_with_default_user_type(self):
        user = CustomUser.objects.create_user(username="test_user", password="password")
        self.assertEqual(user.user_type, CustomUser.USER)

    def test_create_user_with_landlord_user_type(self):
        user = CustomUser.objects.create_user(
            username="landlord_user", password="password", user_type=CustomUser.LANDLORD
        )
        self.assertEqual(user.user_type, CustomUser.LANDLORD)

    def test_create_superuser_with_default_user_type(self):
        superuser = CustomUser.objects.create_superuser(
            username="superuser", password="password"
        )
        self.assertEqual(superuser.user_type, CustomUser.USER)

    def test_create_superuser_with_landlord_user_type(self):
        superuser = CustomUser.objects.create_superuser(
            username="superuser", password="password", user_type=CustomUser.LANDLORD
        )
        self.assertEqual(superuser.user_type, CustomUser.LANDLORD)


class UserSignUpTest(TestCase):
    def test_user_signup_form_display_on_get_request(self):
        response = self.client.get(reverse("user_signup"))
        self.assertEqual(response.status_code, 200)
        self.assertIsInstance(response.context["form"], UserSignUpForm)
        self.assertTemplateUsed(response, "users/signup/signup.html")

    def test_user_signup_success_on_valid_post_request(self):
        form_data = {
            "username": "testuser",
            "email": "testuser@nyu.edu",
            "full_name": "Test User",
            "phone_number": "1234567890",
            "city": "Test City",
            "s3_doclink": "http://example.com/doc",
            "password1": "testpassword123",
            "password2": "testpassword123",
        }
        response = self.client.post(reverse("user_signup"), form_data)
        self.assertEqual(User.objects.count(), 1)
        self.assertRedirects(response, reverse("user_homepage"))

    def test_user_signup_error_on_invalid_post_request(self):
        form_data = {
            "username": "testuser",
            "email": "invalid-email",
            "full_name": "Test User",
            "phone_number": "1234567890",
            "city": "Test City",
            "password1": "testpassword123",
            "password2": "wrongpassword",
        }
        response = self.client.post(reverse("user_signup"), form_data)
        self.assertEqual(User.objects.count(), 0)
        self.assertFormError(response, "form", "email", "Enter a valid email address.")


class LoginProcessTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        # Create a user and a landlord for testing login
        cls.user = CustomUser.objects.create_user(
            username="testuser", password="testpassword", user_type=CustomUser.USER
        )
        cls.landlord = CustomUser.objects.create_user(
            username="testlandlord",
            password="testpassword",
            user_type=CustomUser.LANDLORD,
            verified=True,
        )
        cls.landlord.save()

    def test_user_login_success(self):
        response = self.client.post(
            reverse("user_login"), {"username": "testuser", "password": "testpassword"}
        )
        self.assertRedirects(response, reverse("user_homepage"))


class LogoutViewTest(TestCase):
    def test_logout_redirect(self):
        response = self.client.get(reverse("logout"))
        self.assertRedirects(response, "/")


class Custom404HandlerTest(TestCase):
    def test_redirect_for_authenticated_landlord(self):
        landlord = CustomUser.objects.create_user(
            username="landlord404", password="password", user_type=CustomUser.LANDLORD
        )
        self.client.login(username="landlord404", password="password")
        self.assertIsNotNone(landlord.id)
        response = self.client.get("/nonexistentpage")
        self.assertRedirects(response, reverse("landlord_homepage"))

    def test_redirect_for_authenticated_user(self):
        user = CustomUser.objects.create_user(
            username="user404", password="password", user_type=CustomUser.USER
        )
        self.client.login(username="user404", password="password")
        self.assertIsNotNone(user.id)
        response = self.client.get("/nonexistentpage")
        self.assertRedirects(response, reverse("user_homepage"))

    def test_redirect_for_unauthenticated_user(self):
        response = self.client.get("/nonexistentpage")
        self.assertRedirects(response, reverse("index"))


class LandlordSignUpTest(TestCase):
    def test_landlord_signup_form_display_on_get_request(self):
        response = self.client.get(reverse("landlord_signup"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "signup/landlord_signup.html")

    def test_landlord_signup_success_on_valid_post_request(self):
        form_data = {
            "username": "landlorduser",
            "email": "landlord@nyu.edu",
            "full_name": "Landlord User",
            "phone_number": "0987654321",
            "city": "Landlord City",
            "password1": "landlordpassword123",
            "password2": "landlordpassword123",
            # Assume "pdf_file" is optional for simplicity; otherwise,
            # use SimpleUploadedFile for tests
        }
        response = self.client.post(reverse("landlord_signup"), form_data)
        self.assertEqual(
            CustomUser.objects.filter(user_type=CustomUser.LANDLORD).count(), 1
        )
        self.assertRedirects(response, reverse("landlord_login"))

    def test_landlord_signup_error_on_invalid_post_request(self):
        form_data = {
            "username": "landlorduser",
            "email": "landlorduser@nyu.edu",
            # Missing fields
            "password1": "landlordpassword123",
            "password2": "landlordpassword123",
        }
        response = self.client.post(reverse("landlord_signup"), form_data)
        self.assertEqual(CustomUser.objects.count(), 0)
        self.assertTrue(response.context["form"].errors)


class UserSignUpFormTest(TestCase):
    def test_invalid_email_domain(self):
        form_data = {
            "email": "user@example.com",  # Invalid email domain
            "full_name": "Test User",
            "phone_number": "1234567890",
            "city": "New York",
            "password1": "strongpassword",
            "password2": "strongpassword",
        }
        form = UserSignUpForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)


class CustomUserModelStrTest(TestCase):
    def test_custom_user_str(self):
        user = CustomUser.objects.create_user(
            username="testuser", email="testuser@nyu.edu"
        )
        self.assertEqual(str(user), "testuser")


class LandingPageViewTest(TestCase):
    def test_landing_page_status_code(self):
        response = self.client.get(reverse("index"))
        self.assertEqual(response.status_code, 200)


class LogoutTest(TestCase):
    def test_logout_functionality(self):
        user = CustomUser.objects.create_user(username="testuser", password="password")
        self.client.login(username="testuser", password="password")
        response = self.client.get(reverse("logout"))
        self.assertNotIn("_auth_user_id", self.client.session)


class UserAccessTest(TestCase):
    def test_protected_view_access(self):
        response = self.client.get(reverse("user_homepage"))
        self.assertEqual(response.status_code, 302)  # Redirect to login page


class PasswordResetViewTest(TestCase):
    def test_password_reset_page(self):
        response = self.client.get(reverse("password_reset_form"))
        self.assertEqual(response.status_code, 200)


# class RentalsPageViewTest(TestCase):
#     def test_rentals_page_view(self):
#         response = self.client.get(reverse('rentalspage'))
#         self.assertEqual(response.status_code, 302)
#         self.assertTemplateUsed(response, 'users/searchRental/rentalspage.html')


class RentalListingsModelTests(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="testuser", email="test@nyu.edu", password="testpass123"
        )

    # def test_rental_listing_creation(self):
    #     listing = Rental_Listings.objects.create(
    #         address='123 Test St',
    #         price=2000.00,
    #         Landlord=self.user,
    #         Submitted_date=date.today()
    #     )
    #     self.assertEqual(Rental_Listings.objects.count(), 1)
    #     self.assertEqual(listing.address, '123 Test St')
    #     self.assertEqual(listing.Landlord, self.user)


class UserSignUpFormTests(TestCase):
    def test_clean_email_valid(self):
        form_data = {
            "username": "valid@nyu.edu",
            "email": "valid@nyu.edu",
            "password1": "testpassword",
            "password2": "testpassword",
            "full_name": "Valid User",
            "phone_number": "1234567890",
            "city": "New York",
        }
        form = UserSignUpForm(data=form_data)
        self.assertTrue(form.is_valid())

    def test_clean_email_invalid_domain(self):
        form_data = {
            "username": "invalid@gmail.com",
            "email": "invalid@gmail.com",
            "password1": "testpassword",
            "password2": "testpassword",
            "full_name": "Invalid User",
            "phone_number": "1234567890",
            "city": "New York",
        }
        form = UserSignUpForm(data=form_data)
        self.assertFalse(form.is_valid())
        self.assertIn("email", form.errors)


class LandlordSignupFormTests(TestCase):
    def test_form_save(self):
        form_data = {
            "username": "landlord@nyu.edu",
            "email": "landlord@nyu.edu",
            "password1": "landlordpassword",
            "password2": "landlordpassword",
            "full_name": "Landlord User",
            "phone_number": "9876543210",
            "city": "New York",
        }
        form = LandlordSignupForm(data=form_data)
        self.assertTrue(form.is_valid())
        landlord = form.save()
        self.assertEqual(landlord.email, "landlord@nyu.edu")
        self.assertEqual(landlord.user_type, CustomUser.LANDLORD)


class FavoriteModelTests(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="favuser", email="favuser@nyu.edu", password="testpass123"
        )
        self.listing = Rental_Listings.objects.create(
            address="123 Fav St", price=1500.00, baths=1, Landlord=self.user
        )
        self.client = Client()
        self.client.login(username="favuser", password="testpass123")
        self.toggle_favorite_url = reverse("toggle_favorite")

    def test_toggle_favorite_add(self):
        response = self.client.post(
            self.toggle_favorite_url, {"listing_id": self.listing.id}
        )
        self.assertEqual(response.status_code, 200)
        self.assertEqual(Favorite.objects.count(), 1)
        self.assertJSONEqual(
            str(response.content, encoding="utf8"), {"status": "added"}
        )

    def test_toggle_favorite_remove(self):
        Favorite.objects.create(user=self.user, listing=self.listing)
        response = self.client.post(
            self.toggle_favorite_url, {"listing_id": self.listing.id}
        )
        self.assertEqual(response.status_code, 200)
        self.assertEqual(Favorite.objects.count(), 0)
        self.assertJSONEqual(
            str(response.content, encoding="utf8"), {"status": "removed"}
        )

    def test_toggle_favorite_with_invalid_listing(self):
        response = self.client.post(
            self.toggle_favorite_url, {"listing_id": 9999}
        )  # Assuming 9999 is an invalid ID
        self.assertEqual(response.status_code, 404)
        self.assertJSONEqual(
            str(response.content, encoding="utf8"), {"error": "Listing not found"}
        )

    def test_toggle_favorite_without_listing_id(self):
        response = self.client.post(self.toggle_favorite_url, {})
        self.assertEqual(response.status_code, 400)
        self.assertJSONEqual(
            str(response.content, encoding="utf8"), {"error": "Listing ID is required"}
        )


class LogoutViewTests(TestCase):
    def test_logout(self):
        self.client.login(username="testuser", password="testpass123")
        response = self.client.get(reverse("logout"))
        self.assertRedirects(response, "/")


class HomeViewTests(TestCase):
    def test_home_view_status_code(self):
        response = self.client.get(reverse("index"))
        self.assertEqual(response.status_code, 200)


# class UserHomeViewTests(TestCase):
#     def test_user_home_redirect_for_anonymous(self):
#         response = self.client.get(reverse('user_homepage'), follow=True)
#         self.assertRedirects(response, '/login/user_login?next=/user/home/')

# class LandlordHomeViewTests(TestCase):
#     def test_landlord_home_redirect_for_anonymous(self):
#         response = self.client.get(reverse('landlord_homepage'), follow=True)
#         self.assertRedirects(response, '/login/landlord_login?next=/landlord/home/')


class RentalsPageViewTests(TestCase):
    def test_rentals_page_for_user(self):
        self.client.login(username="testuser", password="testpass123")
        response = self.client.get(reverse("rentalspage"))
        self.assertEqual(response.status_code, 302)


# class FavoritesPageViewTests(TestCase):
#     def test_favorites_page_for_user(self):
#         self.client.login(username='testuser', password='testpass123')  # Make sure the user is logged in
#         response = self.client.get(reverse('favorites_page'))
#         self.assertEqual(response.status_code, 200)


class UserSignUpViewTests(TestCase):
    def test_user_signup_with_invalid_data(self):
        response = self.client.post(reverse("user_signup"), {})
        self.assertEqual(response.status_code, 200)
        self.assertTrue(response.context["form"].errors)


class LandlordSignUpViewTests(TestCase):
    def test_landlord_signup_with_valid_data(self):
        form_data = {
            "username": "newlandlord",
            "email": "newlandlord@nyu.edu",
            "password1": "landlordpassword123",
            "password2": "landlordpassword123",
            "full_name": "New Landlord",
            "phone_number": "1234567890",
            "city": "New York City",
        }
        response = self.client.post(reverse("landlord_signup"), form_data)
        self.assertRedirects(response, reverse("landlord_login"))
        self.assertEqual(
            CustomUser.objects.filter(user_type=CustomUser.LANDLORD).count(), 1
        )


class UserLoginViewTests(TestCase):
    def test_user_login_redirect(self):
        user = CustomUser.objects.create_user(
            username="loginuser", email="loginuser@nyu.edu", password="password"
        )
        response = self.client.post(
            reverse("user_login"), {"username": "loginuser", "password": "password"}
        )
        self.assertRedirects(response, reverse("user_homepage"))


# class UserHomePageViewTests(TestCase):
#     def test_user_homepage_access_unauthenticated(self):
#         response = self.client.get(reverse("user_homepage"))
#         self.assertEqual(response.status_code, 302)
#         self.assertTrue(reverse("user_login") in response.url)


class UserHomePageAuthenticatedAccessTests(TestCase):
    def test_user_homepage_access_authenticated(self):
        user = CustomUser.objects.create_user(
            username="testuserhome", email="testuserhome@nyu.edu", password="password"
        )
        self.client.login(username="testuserhome", password="password")
        response = self.client.get(reverse("user_homepage"))
        self.assertEqual(response.status_code, 200)


class LogoutFunctionalityTests(TestCase):
    def test_logout_redirects_to_home(self):
        self.client.login(username="testuser", password="testpass123")
        response = self.client.get(reverse("logout"))
        self.assertRedirects(response, reverse("index"))


class RentalListingsAccessTests(TestCase):
    def test_rental_listings_access_by_authenticated_user(self):
        self.client.login(username="testuser", password="testpass123")
        response = self.client.get(reverse("rentalspage"))
        self.assertEqual(response.status_code, 302)


class LandlordSignupWithFileTest(TestCase):
    @patch("users.views.boto3.client")
    def test_landlord_signup_with_file(self, mock_boto3_client):
        mock_s3_client = mock_boto3_client.return_value
        mock_s3_client.upload_fileobj.return_value = None  # Simulate successful upload

        form_data = {
            "username": "landlordfile@nyu.edu",
            "email": "landlordfile@nyu.edu",
            "password1": "landlordpassword",
            "password2": "landlordpassword",
            "full_name": "Landlord File",
            "phone_number": "9876543210",
            "city": "New York",
            "pdf_file": SimpleUploadedFile(
                "test_file.pdf",
                b"These are the file contents.",
                content_type="application/pdf",
            ),
        }
        response = self.client.post(reverse("landlord_signup"), form_data)
        self.assertRedirects(response, reverse("landlord_login"))
        self.assertTrue(
            CustomUser.objects.filter(email="landlordfile@nyu.edu").exists()
        )


class UserLoginRedirectTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.user = CustomUser.objects.create_user(
            username="testuserredirect",
            email="userredirect@nyu.edu",
            password="password123",
            user_type=CustomUser.USER,
        )

    def test_user_login_redirect_to_user_homepage(self):
        self.client.login(username="testuserredirect", password="password123")
        response = self.client.get(reverse("user_homepage"))
        self.assertEqual(response.status_code, 200)


class Custom404HandlerTest(TestCase):
    def test_404_redirect_for_anonymous_user(self):
        response = self.client.get("/thispagedoesnotexist")
        self.assertRedirects(response, reverse("index"))

    def test_404_redirect_for_authenticated_user(self):
        user = CustomUser.objects.create_user(
            username="user404test", password="password"
        )
        self.client.login(username="user404test", password="password")
        response = self.client.get("/thispagedoesnotexist")
        self.assertRedirects(response, reverse("user_homepage"))


class ToggleFavoriteTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.user = CustomUser.objects.create_user(
            username="favuser",
            email="favuser@nyu.edu",
            password="testpass123",
            user_type=CustomUser.USER,
        )
        cls.listing = Rental_Listings.objects.create(
            address="123 Fav St", price=1500.00, baths=1, Landlord=cls.user
        )

    # def test_toggle_favorite_add(self):
    #     self.client.login(username='favuser', password='testpass123')
    #     response = self.client.post(reverse('toggle_favorite'), json.dumps({'listing_id': self.listing.id}), content_type='application/json')
    #     self.assertEqual(response.status_code, 400)
    #     self.assertTrue(Favorite.objects.filter(user=self.user, listing=self.listing).exists())


class LandlordUserPageAccessTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.landlord_user = CustomUser.objects.create_user(
            username="landlorduser",
            email="landlorduser@nyu.edu",
            password="testpass123",
            user_type=CustomUser.LANDLORD,
        )
        cls.user = CustomUser.objects.create_user(
            username="normaluser",
            email="normaluser@nyu.edu",
            password="testpass123",
            user_type=CustomUser.USER,
        )

    def test_landlord_accessing_user_page(self):
        self.client.login(username="landlorduser", password="testpass123")
        response = self.client.get(reverse("user_homepage"))
        self.assertNotEqual(response.status_code, 200)

    def test_user_accessing_landlord_page(self):
        self.client.login(username="normaluser", password="testpass123")
        response = self.client.get(reverse("landlord_homepage"))
        self.assertNotEqual(response.status_code, 200)


class ListingDetailViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(username="testuser", password="password")
        self.client.login(username="testuser", password="password")

        self.listing = Rental_Listings.objects.create(
            address="123 Main St",
            beds=2,
            baths=2,
            price=2000,
            borough="Brooklyn",
            neighborhood="Park Slope",
            sq_ft=1000,
            Availability_Date="2024-04-03",
            latitude=40.1234,
            longitude=-73.5678,
        )

    # def test_listing_detail_view(self):
    #     response = self.client.get(
    #         reverse("listing_detail", kwargs={"listing_id": self.listing.pk})
    #     )
    #     self.assertEqual(response.status_code, 200)
    #     self.assertContains(response, self.listing.address)
    #     self.assertContains(response, self.listing.beds)
    #     self.assertContains(response, self.listing.baths)

    def test_toggle_favorite_ajax(self):
        response = self.client.post(
            reverse("toggle_favorite"), {"listing_id": self.listing.pk}
        )
        self.assertEqual(response.status_code, 200)

    def test_listing_detail_not_found(self):
        non_existent_listing_id = 99999  # Assuming this ID does not exist
        response = self.client.get(
            reverse("listing_detail", kwargs={"listing_id": non_existent_listing_id})
        )
        self.assertEqual(response.status_code, 302)


# class InitTestCase(TestCase):
#     def test_default_settings(self):
#         # Do not set ENV_NAME or set it to a value other than "prod" or "develop"
#         from rent_wise_nyc import settings
#         # Assert that settings imported from local.py are correctly applied
#         self.assertEqual(settings.ALLOWED_HOSTS, ["127.0.0.1"])


class ManagePyTestCase(unittest.TestCase):
    @patch.dict(os.environ, {"DJANGO_SETTINGS_MODULE": "rent_wise_nyc.settings"})
    @patch("django.core.management.execute_from_command_line")
    def test_main_success(self, mock_execute_from_command_line):
        from manage import main

        main()
        mock_execute_from_command_line.assert_called_once_with(sys.argv)

    @patch("django.core.management.execute_from_command_line", side_effect=ImportError)
    def test_main_import_error(self, mock_execute_from_command_line):
        from manage import main

        with self.assertRaises(ImportError):
            main()


class ProfileUpdateTestCase(TestCase):
    def setUp(self):
        # Create a test user
        self.user = CustomUser.objects.create_user(
            username="testuser",
            email="test@example.com",
            password="testpassword123",
            user_type="user",
        )
        self.client.login(username="testuser", password="testpassword123")

    def test_profile_update_form_loads_correctly(self):
        """Test that the profile update form loads with the correct initial data."""
        response = self.client.get(reverse("profile_view_edit"))
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response, 'value="test@example.com"'
        )  # Check for pre-filled email
        self.assertContains(
            response, 'value="testuser"'
        )  # Check for pre-filled username

    def test_unauthenticated_access_redirects_to_login(self):
        """Test that unauthenticated users are redirected to the login page."""
        self.client.logout()  # Log out to test unauthenticated access
        response = self.client.get(reverse("profile_view_edit"))
        self.assertRedirects(
            response, f"/accounts/login/?next={reverse('profile_view_edit')}"
        )

    def test_successful_profile_update(self):
        """Test submitting the form with valid data updates the user's profile."""
        data = {
            "full_name": "Test User",
            "phone_number": 9876543211,
            "city": "New York",
        }
        response = self.client.post(reverse("profile_view_edit"), data)
        self.assertEqual(response.status_code, 302)
        self.user.refresh_from_db()
        self.assertEqual(self.user.full_name, "Test User")
        messages = [msg.message for msg in get_messages(response.wsgi_request)]
        self.assertIn("Your profile was successfully updated!", messages)

    def test_invalid_form_submission(self):
        """Test that invalid form submissions are handled correctly."""
        data = {
            "full_name": "",
        }
        response = self.client.post(reverse("profile_view_edit"), data)
        self.assertEqual(response.status_code, 200)  # Page reloads with form errors
        self.assertFormError(response, "form", "full_name", "This field is required.")


class LandlordProfileUpdateTestCase(TestCase):
    def setUp(self):
        # Create a test user
        self.user = CustomUser.objects.create_user(
            username="testlandlord",
            email="test@example.com",
            password="testpassword123",
            user_type="landlord",
        )
        self.client.login(username="testlandlord", password="testpassword123")

    def test_profile_update_form_loads_correctly(self):
        """Test that the profile update form loads with the correct initial data."""
        response = self.client.get(reverse("landlord_profile_update"))
        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response, 'value="test@example.com"'
        )  # Check for pre-filled email
        self.assertContains(
            response, 'value="testlandlord"'
        )  # Check for pre-filled username

    def test_unauthenticated_access_redirects_to_login(self):
        """Test that unauthenticated users are redirected to the login page."""
        self.client.logout()  # Log out to test unauthenticated access
        response = self.client.get(reverse("landlord_profile_update"))
        self.assertRedirects(
            response, f"/accounts/login/?next={reverse('landlord_profile_update')}"
        )

    def test_successful_profile_update(self):
        """Test submitting the form with valid data updates the user's profile."""
        data = {
            "full_name": "Test Landlord",
            "phone_number": 9876543211,
            "city": "New York",
        }
        response = self.client.post(reverse("landlord_profile_update"), data)
        self.assertEqual(response.status_code, 302)
        self.user.refresh_from_db()
        self.assertEqual(self.user.full_name, "Test Landlord")
        messages = [msg.message for msg in get_messages(response.wsgi_request)]
        self.assertIn("Your profile was successfully updated!", messages)

    def test_invalid_form_submission(self):
        """Test that invalid form submissions are handled correctly."""
        data = {
            "full_name": "",
        }
        response = self.client.post(reverse("landlord_profile_update"), data)
        self.assertEqual(response.status_code, 200)  # Page reloads with form errors
        self.assertFormError(response, "form", "full_name", "This field is required.")


class RentalListingsFormTests(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="testuser", email="test@nyu.edu", password="testpass123"
        )

        self.common_data = {
            "address": "123 Main St",
            "zipcode": "10001",
            "price": 1500,
            "sq_ft": 500,
            "rooms": 3,
            "beds": 2,
            "baths": 1.5,
            "unit_type": "Apartment",
            "neighborhood": "Midtown",
            "borough": "Manhattan",
            "broker_fee": False,
            "central_air_conditioning": True,
            "dishwasher": True,
            "doorman": False,
            "elevator": True,
            "furnished": False,
            "parking_available": True,
            "washer_dryer_in_unit": False,
            "Submitted_date": date.today(),
            "Availability_Date": date.today() + timedelta(days=10),
        }

    def test_form_with_valid_data(self):
        form = RentalListingForm(data=self.common_data)

    def test_form_with_negative_price(self):
        data = self.common_data.copy()
        data["price"] = -100
        form = RentalListingForm(data=data)
        self.assertFalse(form.is_valid())
        self.assertIn("price", form.errors)
        self.assertEqual(form.errors["price"], ["Price cannot be negative."])

    def test_form_with_invalid_zipcode(self):
        data = self.common_data.copy()
        data["zipcode"] = "123"
        form = RentalListingForm(data=data)
        self.assertFalse(form.is_valid())
        self.assertIn("zipcode", form.errors)
        self.assertEqual(
            form.errors["zipcode"], ["Please enter a valid 5-digit zip code."]
        )

    def test_form_with_invalid_availability_date(self):
        data = self.common_data.copy()
        data["Availability_Date"] = date.today() - timedelta(days=1)
        form = RentalListingForm(data=data)
        self.assertFalse(form.is_valid())
        self.assertIn("Availability_Date", form.errors)
        self.assertEqual(
            form.errors["Availability_Date"],
            ["The availability date cannot be in the past."],
        )

    def test_form_with_rooms_less_than_beds(self):
        data = self.common_data.copy()
        data["rooms"] = 1
        data["beds"] = 2
        form = RentalListingForm(data=data)
        self.assertFalse(form.is_valid())

    def test_form_with_large_address(self):
        data = self.common_data.copy()
        data["address"] = "x" * 256
        form = RentalListingForm(data=data)
        self.assertFalse(form.is_valid())


class TestApplyFilters(TestCase):
    def setUp(self):
        # Creating test listings
        self.listing1 = Rental_Listings.objects.create(
            neighborhood="Manhattan",
            borough="Manhattan",
            price=2000,
            beds=2,
            baths=1,
            elevator=True,
            washer_dryer_in_unit=False,
            broker_fee=0,
            unit_type="Apartment",
            address="123 Main Street",
        )
        self.listing2 = Rental_Listings.objects.create(
            neighborhood="Brooklyn",
            borough="Brooklyn",
            price=1500,
            beds=1,
            baths=1,
            elevator=False,
            washer_dryer_in_unit=True,
            broker_fee=500,
            unit_type="House",
            address="124 Main Street",
        )
        self.listing3 = Rental_Listings.objects.create(
            neighborhood="Queens",
            borough="Queens",
            price=1000,
            beds=3,
            baths=2,
            elevator=True,
            washer_dryer_in_unit=True,
            broker_fee=300,
            unit_type="Apartment",
            address="125 Main Street",
        )

    def test_filter_by_borough(self):
        filter_params = {"borough": "Manhattan"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertTrue(self.listing1 in filtered_listings)
        self.assertFalse(self.listing2 in filtered_listings)
        self.assertFalse(self.listing3 in filtered_listings)

    def test_filter_by_price_range(self):
        filter_params = {"min_price": 1200, "max_price": 2500}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertTrue(self.listing1 in filtered_listings)
        self.assertTrue(self.listing2 in filtered_listings)
        self.assertFalse(self.listing3 in filtered_listings)

    def test_filter_by_bedrooms(self):
        filter_params = {"bedrooms": "2"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertTrue(self.listing1 in filtered_listings)
        self.assertFalse(self.listing2 in filtered_listings)

    def test_filter_by_elevator(self):
        filter_params = {"elevator": True}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertTrue(self.listing1 in filtered_listings)
        self.assertFalse(self.listing2 in filtered_listings)
        self.assertTrue(self.listing3 in filtered_listings)

    def test_no_filters(self):
        filter_params = {}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertEqual(len(filtered_listings), 3)

    def test_filter_no_fee(self):
        filter_params = {"no_fee": True}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertIn(
            self.listing1, filtered_listings
        )  # Assuming listing1 has no broker fee
        self.assertNotIn(
            self.listing2, filtered_listings
        )  # Assuming listing2 has a broker fee

    def test_filter_laundry(self):
        filter_params = {"laundry": True}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertNotIn(
            self.listing1, filtered_listings
        )  # Assuming listing1 does not have laundry
        self.assertIn(self.listing2, filtered_listings)  # Assuming listing2 has laundry

    def test_filter_building_type(self):
        filter_params = {"building_type": "Apartment"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertIn(self.listing1, filtered_listings)
        self.assertNotIn(self.listing2, filtered_listings)

    def test_filter_parking(self):
        filter_params = {"parking": True}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)

    def test_filter_search_query(self):
        filter_params = {"search_query": "Main Street"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        pass

    def test_filter_bathrooms(self):
        filter_params = {"bathrooms": "Any"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)
        self.assertEqual(len(filtered_listings), Rental_Listings.objects.count())
        filter_params = {"bathrooms": "1"}
        filtered_listings = apply_filters(Rental_Listings.objects.all(), filter_params)


class EditRentalListingViewTestCase(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="landlord_user", password="password", user_type=CustomUser.LANDLORD
        )
        self.client.force_login(self.user)
        self.rental_listing = Rental_Listings.objects.create(
            Landlord=self.user,
            address="Test Address",
            price=1000,
            baths=2,
            beds=1,
            rooms=4,
        )

    def test_edit_rental_listing_view_get(self):
        response = self.client.get(
            reverse("edit_rental_listing", args=[self.rental_listing.id])
        )
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "edit_rental_listing.html")


class DeleteRentalListingViewTestCase(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="landlord_user", password="password", user_type=CustomUser.LANDLORD
        )
        self.client.force_login(self.user)
        self.rental_listing = Rental_Listings.objects.create(
            Landlord=self.user,
            address="Test Address",
            price=1000,
            baths=2,
            beds=1,
            rooms=4,
        )


class LandlordProfileUpdateViewTestCase(TestCase):
    def setUp(self):
        self.user = CustomUser.objects.create_user(
            username="landlord_user", password="password", user_type=CustomUser.LANDLORD
        )
        self.client.force_login(self.user)

    def test_landlord_profile_update_view_get(self):
        response = self.client.get(reverse("landlord_profile_update"))
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "users/Profile/landlord_profile_update.html")
        self.assertIsInstance(response.context["form"], CustomUserEditForm)
        self.assertEqual(response.context["user"], self.user)


class AddRentalListingViewTestCase(TestCase):
    def setUp(self):
        self.factory = RequestFactory()
        self.user = CustomUser.objects.create_user(
            username="landlord_user", password="password", user_type=CustomUser.LANDLORD
        )
        self.user.user_type = (
            "landlord"  # Assuming you have a custom user model with a user_type field
        )
        self.client.force_login(self.user)

    def test_add_rental_listing_view_get(self):
        request = self.factory.get(reverse("post_new_listings"))
        request.user = self.user
        response = add_rental_listing(request)

    def test_add_rental_listing_view_post(self):
        post_data = {
            "address": "Test Address",
            "price": 1000,
            "baths": 2,
            "beds": 1,
            "rooms": 4,
        }
        request = self.factory.post(reverse("post_new_listings"), post_data)
        request.user = self.user
        response = add_rental_listing(request)
        self.assertEqual(response.status_code, 200)  # Redirect expected

gcivil-nyu-org / INET-Wednesday-Spring2024-Team-2 / 638

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous