thrillwiki_django_no_react/companies/tests.py

from django.test import TestCase, Client
from django.urls import reverse
from django.core.exceptions import ValidationError
from django.contrib.contenttypes.models import ContentType
from django.contrib.gis.geos import Point
from django.contrib.auth import get_user_model
from django.core.files.uploadedfile import SimpleUploadedFile
from .models import Company, Manufacturer
from location.models import Location
from moderation.models import EditSubmission, PhotoSubmission
from media.models import Photo

User = get_user_model()

class CompanyModelTests(TestCase):
    def setUp(self):
        self.company = Company.objects.create(
            name='Test Company',
            website='http://example.com',
            headquarters='Test HQ',
            description='Test Description',
            total_parks=5,
            total_rides=100
        )
        
        self.location = Location.objects.create(
            content_type=ContentType.objects.get_for_model(Company),
            object_id=self.company.pk,
            name='Test Company HQ',
            location_type='business',
            street_address='123 Company St',
            city='Company City',
            state='CS',
            country='Test Country',
            postal_code='12345',
            point=Point(-118.2437, 34.0522)
        )

    def test_company_creation(self):
        """Test company instance creation and field values"""
        self.assertEqual(self.company.name, 'Test Company')
        self.assertEqual(self.company.website, 'http://example.com')
        self.assertEqual(self.company.headquarters, 'Test HQ')
        self.assertEqual(self.company.description, 'Test Description')
        self.assertEqual(self.company.total_parks, 5)
        self.assertEqual(self.company.total_rides, 100)
        self.assertTrue(self.company.slug)

    def test_company_str_representation(self):
        """Test string representation of company"""
        self.assertEqual(str(self.company), 'Test Company')

    def test_company_get_by_slug(self):
        """Test get_by_slug class method"""
        company, is_historical = Company.get_by_slug(self.company.slug)
        self.assertEqual(company, self.company)
        self.assertFalse(is_historical)

    def test_company_get_by_invalid_slug(self):
        """Test get_by_slug with invalid slug"""
        with self.assertRaises(Company.DoesNotExist):
            Company.get_by_slug('invalid-slug')

    def test_company_stats(self):
        """Test company statistics fields"""
        self.company.total_parks = 10
        self.company.total_rides = 200
        self.company.save()
        
        company = Company.objects.get(pk=self.company.pk)
        self.assertEqual(company.total_parks, 10)
        self.assertEqual(company.total_rides, 200)

class ManufacturerModelTests(TestCase):
    def setUp(self):
        self.manufacturer = Manufacturer.objects.create(
            name='Test Manufacturer',
            website='http://example.com',
            headquarters='Test HQ',
            description='Test Description',
            total_rides=50,
            total_roller_coasters=20
        )
        
        self.location = Location.objects.create(
            content_type=ContentType.objects.get_for_model(Manufacturer),
            object_id=self.manufacturer.pk,
            name='Test Manufacturer HQ',
            location_type='business',
            street_address='123 Manufacturer St',
            city='Manufacturer City',
            state='MS',
            country='Test Country',
            postal_code='12345',
            point=Point(-118.2437, 34.0522)
        )

    def test_manufacturer_creation(self):
        """Test manufacturer instance creation and field values"""
        self.assertEqual(self.manufacturer.name, 'Test Manufacturer')
        self.assertEqual(self.manufacturer.website, 'http://example.com')
        self.assertEqual(self.manufacturer.headquarters, 'Test HQ')
        self.assertEqual(self.manufacturer.description, 'Test Description')
        self.assertEqual(self.manufacturer.total_rides, 50)
        self.assertEqual(self.manufacturer.total_roller_coasters, 20)
        self.assertTrue(self.manufacturer.slug)

    def test_manufacturer_str_representation(self):
        """Test string representation of manufacturer"""
        self.assertEqual(str(self.manufacturer), 'Test Manufacturer')

    def test_manufacturer_get_by_slug(self):
        """Test get_by_slug class method"""
        manufacturer, is_historical = Manufacturer.get_by_slug(self.manufacturer.slug)
        self.assertEqual(manufacturer, self.manufacturer)
        self.assertFalse(is_historical)

    def test_manufacturer_get_by_invalid_slug(self):
        """Test get_by_slug with invalid slug"""
        with self.assertRaises(Manufacturer.DoesNotExist):
            Manufacturer.get_by_slug('invalid-slug')

    def test_manufacturer_stats(self):
        """Test manufacturer statistics fields"""
        self.manufacturer.total_rides = 100
        self.manufacturer.total_roller_coasters = 40
        self.manufacturer.save()
        
        manufacturer = Manufacturer.objects.get(pk=self.manufacturer.pk)
        self.assertEqual(manufacturer.total_rides, 100)
        self.assertEqual(manufacturer.total_roller_coasters, 40)

class CompanyViewTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )
        self.moderator = User.objects.create_user(
            username='moderator',
            email='moderator@example.com',
            password='modpass123',
            role='MODERATOR'
        )
        self.company = Company.objects.create(
            name='Test Company',
            website='http://example.com',
            headquarters='Test HQ',
            description='Test Description'
        )
        
        self.location = Location.objects.create(
            content_type=ContentType.objects.get_for_model(Company),
            object_id=self.company.pk,
            name='Test Company HQ',
            location_type='business',
            street_address='123 Company St',
            city='Company City',
            state='CS',
            country='Test Country',
            postal_code='12345',
            point=Point(-118.2437, 34.0522)
        )

    def test_company_list_view(self):
        """Test company list view"""
        response = self.client.get(reverse('companies:company_list'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.company.name)

    def test_company_list_view_with_search(self):
        """Test company list view with search"""
        response = self.client.get(reverse('companies:company_list') + '?search=Test')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.company.name)

        response = self.client.get(reverse('companies:company_list') + '?search=NonExistent')
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, self.company.name)

    def test_company_list_view_with_country_filter(self):
        """Test company list view with country filter"""
        response = self.client.get(reverse('companies:company_list') + '?country=Test Country')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.company.name)

        response = self.client.get(reverse('companies:company_list') + '?country=NonExistent')
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, self.company.name)

    def test_company_detail_view(self):
        """Test company detail view"""
        response = self.client.get(
            reverse('companies:company_detail', kwargs={'slug': self.company.slug})
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.company.name)
        self.assertContains(response, self.company.website)
        self.assertContains(response, self.company.headquarters)

    def test_company_detail_view_invalid_slug(self):
        """Test company detail view with invalid slug"""
        response = self.client.get(
            reverse('companies:company_detail', kwargs={'slug': 'invalid-slug'})
        )
        self.assertEqual(response.status_code, 404)

    def test_company_create_view_unauthenticated(self):
        """Test company create view when not logged in"""
        response = self.client.get(reverse('companies:company_create'))
        self.assertEqual(response.status_code, 302)  # Redirects to login

    def test_company_create_view_authenticated(self):
        """Test company create view when logged in"""
        self.client.login(username='testuser', password='testpass123')
        response = self.client.get(reverse('companies:company_create'))
        self.assertEqual(response.status_code, 200)

    def test_company_create_submission_regular_user(self):
        """Test creating a company submission as regular user"""
        self.client.login(username='testuser', password='testpass123')
        data = {
            'name': 'New Company',
            'website': 'http://newcompany.com',
            'headquarters': 'New HQ',
            'description': 'New Description',
            'reason': 'Adding new company',
            'source': 'Company website'
        }
        response = self.client.post(reverse('companies:company_create'), data)
        self.assertEqual(response.status_code, 302)  # Redirects after submission
        self.assertTrue(EditSubmission.objects.filter(
            submission_type='CREATE',
            changes__name='New Company',
            status='NEW'
        ).exists())

    def test_company_create_submission_moderator(self):
        """Test creating a company submission as moderator"""
        self.client.login(username='moderator', password='modpass123')
        data = {
            'name': 'New Company',
            'website': 'http://newcompany.com',
            'headquarters': 'New HQ',
            'description': 'New Description',
            'reason': 'Adding new company',
            'source': 'Company website'
        }
        response = self.client.post(reverse('companies:company_create'), data)
        self.assertEqual(response.status_code, 302)  # Redirects after submission
        submission = EditSubmission.objects.get(
            submission_type='CREATE',
            changes__name='New Company'
        )
        self.assertEqual(submission.status, 'APPROVED')
        self.assertEqual(submission.handled_by, self.moderator)

    def test_company_photo_submission(self):
        """Test photo submission for company"""
        self.client.login(username='testuser', password='testpass123')
        image_content = b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;'
        image = SimpleUploadedFile('test.gif', image_content, content_type='image/gif')
        data = {
            'photo': image,
            'caption': 'Test Photo',
            'date_taken': '2024-01-01'
        }
        response = self.client.post(
            reverse('companies:company_detail', kwargs={'slug': self.company.slug}),
            data,
            HTTP_X_REQUESTED_WITH='XMLHttpRequest'  # Simulate AJAX request
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(PhotoSubmission.objects.filter(
            content_type=ContentType.objects.get_for_model(Company),
            object_id=self.company.id
        ).exists())

class ManufacturerViewTests(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )
        self.moderator = User.objects.create_user(
            username='moderator',
            email='moderator@example.com',
            password='modpass123',
            role='MODERATOR'
        )
        self.manufacturer = Manufacturer.objects.create(
            name='Test Manufacturer',
            website='http://example.com',
            headquarters='Test HQ',
            description='Test Description'
        )
        
        self.location = Location.objects.create(
            content_type=ContentType.objects.get_for_model(Manufacturer),
            object_id=self.manufacturer.pk,
            name='Test Manufacturer HQ',
            location_type='business',
            street_address='123 Manufacturer St',
            city='Manufacturer City',
            state='MS',
            country='Test Country',
            postal_code='12345',
            point=Point(-118.2437, 34.0522)
        )

    def test_manufacturer_list_view(self):
        """Test manufacturer list view"""
        response = self.client.get(reverse('companies:manufacturer_list'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.manufacturer.name)

    def test_manufacturer_list_view_with_search(self):
        """Test manufacturer list view with search"""
        response = self.client.get(reverse('companies:manufacturer_list') + '?search=Test')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.manufacturer.name)

        response = self.client.get(reverse('companies:manufacturer_list') + '?search=NonExistent')
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, self.manufacturer.name)

    def test_manufacturer_list_view_with_country_filter(self):
        """Test manufacturer list view with country filter"""
        response = self.client.get(reverse('companies:manufacturer_list') + '?country=Test Country')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.manufacturer.name)

        response = self.client.get(reverse('companies:manufacturer_list') + '?country=NonExistent')
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, self.manufacturer.name)

    def test_manufacturer_detail_view(self):
        """Test manufacturer detail view"""
        response = self.client.get(
            reverse('companies:manufacturer_detail', kwargs={'slug': self.manufacturer.slug})
        )
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, self.manufacturer.name)
        self.assertContains(response, self.manufacturer.website)
        self.assertContains(response, self.manufacturer.headquarters)

    def test_manufacturer_detail_view_invalid_slug(self):
        """Test manufacturer detail view with invalid slug"""
        response = self.client.get(
            reverse('companies:manufacturer_detail', kwargs={'slug': 'invalid-slug'})
        )
        self.assertEqual(response.status_code, 404)

    def test_manufacturer_create_view_unauthenticated(self):
        """Test manufacturer create view when not logged in"""
        response = self.client.get(reverse('companies:manufacturer_create'))
        self.assertEqual(response.status_code, 302)  # Redirects to login

    def test_manufacturer_create_view_authenticated(self):
        """Test manufacturer create view when logged in"""
        self.client.login(username='testuser', password='testpass123')
        response = self.client.get(reverse('companies:manufacturer_create'))
        self.assertEqual(response.status_code, 200)

    def test_manufacturer_create_submission_regular_user(self):
        """Test creating a manufacturer submission as regular user"""
        self.client.login(username='testuser', password='testpass123')
        data = {
            'name': 'New Manufacturer',
            'website': 'http://newmanufacturer.com',
            'headquarters': 'New HQ',
            'description': 'New Description',
            'reason': 'Adding new manufacturer',
            'source': 'Manufacturer website'
        }
        response = self.client.post(reverse('companies:manufacturer_create'), data)
        self.assertEqual(response.status_code, 302)  # Redirects after submission
        self.assertTrue(EditSubmission.objects.filter(
            submission_type='CREATE',
            changes__name='New Manufacturer',
            status='NEW'
        ).exists())

    def test_manufacturer_create_submission_moderator(self):
        """Test creating a manufacturer submission as moderator"""
        self.client.login(username='moderator', password='modpass123')
        data = {
            'name': 'New Manufacturer',
            'website': 'http://newmanufacturer.com',
            'headquarters': 'New HQ',
            'description': 'New Description',
            'reason': 'Adding new manufacturer',
            'source': 'Manufacturer website'
        }
        response = self.client.post(reverse('companies:manufacturer_create'), data)
        self.assertEqual(response.status_code, 302)  # Redirects after submission
        submission = EditSubmission.objects.get(
            submission_type='CREATE',
            changes__name='New Manufacturer'
        )
        self.assertEqual(submission.status, 'APPROVED')
        self.assertEqual(submission.handled_by, self.moderator)

    def test_manufacturer_photo_submission(self):
        """Test photo submission for manufacturer"""
        self.client.login(username='testuser', password='testpass123')
        image_content = b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;'
        image = SimpleUploadedFile('test.gif', image_content, content_type='image/gif')
        data = {
            'photo': image,
            'caption': 'Test Photo',
            'date_taken': '2024-01-01'
        }
        response = self.client.post(
            reverse('companies:manufacturer_detail', kwargs={'slug': self.manufacturer.slug}),
            data,
            HTTP_X_REQUESTED_WITH='XMLHttpRequest'  # Simulate AJAX request
        )
        self.assertEqual(response.status_code, 200)
        self.assertTrue(PhotoSubmission.objects.filter(
            content_type=ContentType.objects.get_for_model(Manufacturer),
            object_id=self.manufacturer.id
        ).exists())