← Back to branch summary

~vcs-imports/reviewboard/trunk

« back to all changes in this revision

Viewing changes to reviewboard/webapi/tests/test_review_request_draft.py

  • Committer: Christian Hammond
  • Date: 2019-01-24 01:59:00 UTC
  • mfrom: (4677.1.178)
  • Revision ID: git-v1:40cabd7ed191e9805fb095aca6808008834bf7d0
Merge branch 'release-4.0.x'

Show diffs side-by-side

added added

removed removed

Lines of Context:
reviewboard/webapi/tests/test_review_request_draft.py
1
 
from __future__ import unicode_literals
 
1
from __future__ import print_function, unicode_literals
2
2
 
3
3
from django.contrib import auth
4
4
from django.contrib.auth.models import Permission, User
10
10
from djblets.webapi.testing.decorators import webapi_test_template
11
11
from kgb import SpyAgency
12
12
 
13
 
from reviewboard.accounts.backends import AuthBackend
 
13
from reviewboard.accounts.backends import AuthBackend, StandardAuthBackend
14
14
from reviewboard.accounts.models import LocalSiteProfile
 
15
from reviewboard.changedescs.models import ChangeDescription
15
16
from reviewboard.diffviewer.features import dvcs_feature
16
17
from reviewboard.reviews.fields import (BaseEditableField,
17
18
                                        BaseTextAreaField,
20
21
from reviewboard.reviews.models import ReviewRequest, ReviewRequestDraft
21
22
from reviewboard.reviews.signals import (review_request_published,
22
23
                                         review_request_publishing)
23
 
from reviewboard.webapi.errors import NOTHING_TO_PUBLISH, PUBLISH_ERROR
 
24
from reviewboard.webapi.errors import (COMMIT_ID_ALREADY_EXISTS,
 
25
                                       NOTHING_TO_PUBLISH,
 
26
                                       PUBLISH_ERROR)
24
27
from reviewboard.webapi.resources import resources
25
28
from reviewboard.webapi.tests.base import BaseWebAPITestCase
26
29
from reviewboard.webapi.tests.mimetypes import \
465
468
        draft = ReviewRequestDraft.create(review_request)
466
469
        self.compare_item(item_rsp, draft)
467
470
 
468
 
    def test_put_with_changedesc(self):
469
 
        """Testing the PUT review-requests/<id>/draft/ API
470
 
        with a change description
471
 
        """
472
 
        changedesc = 'This is a test change description.'
473
 
        review_request = self.create_review_request(submitter=self.user,
474
 
                                                    publish=True)
475
 
 
476
 
        rsp = self.api_put(
477
 
            get_review_request_draft_url(review_request),
478
 
            {'changedescription': changedesc},
479
 
            expected_mimetype=review_request_draft_item_mimetype)
480
 
 
481
 
        self.assertEqual(rsp['stat'], 'ok')
482
 
        self.assertEqual(rsp['draft']['changedescription'], changedesc)
483
 
 
484
 
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
485
 
        self.assertNotEqual(draft.changedesc, None)
486
 
        self.assertEqual(draft.changedesc.text, changedesc)
487
 
 
488
471
    def test_put_with_no_changes(self):
489
472
        """Testing the PUT review-requests/<id>/draft/ API
490
473
        with no changes made to the fields
494
477
 
495
478
        ReviewRequestDraft.create(review_request)
496
479
 
 
480
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
481
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
482
 
497
483
        rsp = self.api_put(
498
484
            get_review_request_draft_url(review_request),
499
485
            {'public': True},
502
488
        self.assertEqual(rsp['stat'], 'fail')
503
489
        self.assertEqual(rsp['err']['code'], NOTHING_TO_PUBLISH.code)
504
490
 
 
491
        self.assertFalse(ChangeDescription.save.called)
 
492
        self.assertFalse(ReviewRequestDraft.save.called)
 
493
 
505
494
    def test_put_with_text_type_markdown(self):
506
495
        """Testing the PUT review-requests/<id>/draft/ API
507
496
        with legacy text_type=markdown
512
501
            expected_change_text_type='markdown',
513
502
            expected_description_text_type='markdown',
514
503
            expected_testing_done_text_type='markdown',
515
 
            expected_custom_field_text_type='markdown')
 
504
            expected_custom_field_text_type='markdown',
 
505
            expected_changedesc_update_fields=['rich_text'],
 
506
            expected_draft_update_fields=['description_rich_text',
 
507
                                          'testing_done_rich_text'])
516
508
 
517
509
    def test_put_with_text_type_plain(self):
518
510
        """Testing the PUT review-requests/<id>/draft/ API
524
516
            expected_change_text_type='plain',
525
517
            expected_description_text_type='plain',
526
518
            expected_testing_done_text_type='plain',
527
 
            expected_custom_field_text_type='plain')
 
519
            expected_custom_field_text_type='plain',
 
520
            expected_changedesc_update_fields=['rich_text'],
 
521
            expected_draft_update_fields=['description_rich_text',
 
522
                                          'testing_done_rich_text'])
528
523
 
529
524
    def test_put_with_changedescription_text_type_markdown(self):
530
525
        """Testing the PUT review-requests/<id>/draft/ API
536
531
            expected_change_text_type='markdown',
537
532
            expected_description_text_type='plain',
538
533
            expected_testing_done_text_type='plain',
539
 
            expected_custom_field_text_type='markdown')
 
534
            expected_custom_field_text_type='markdown',
 
535
            expected_changedesc_update_fields=['rich_text'])
540
536
 
541
537
    def test_put_with_changedescription_text_type_plain(self):
542
538
        """Testing the PUT review-requests/<id>/draft/ API
548
544
            expected_change_text_type='plain',
549
545
            expected_description_text_type='plain',
550
546
            expected_testing_done_text_type='plain',
551
 
            expected_custom_field_text_type='markdown')
 
547
            expected_custom_field_text_type='markdown',
 
548
            expected_changedesc_update_fields=['rich_text'])
552
549
 
553
550
    def test_put_with_description_text_type_markdown(self):
554
551
        """Testing the PUT review-requests/<id>/draft/ API
560
557
            expected_change_text_type='plain',
561
558
            expected_description_text_type='markdown',
562
559
            expected_testing_done_text_type='plain',
563
 
            expected_custom_field_text_type='markdown')
 
560
            expected_custom_field_text_type='markdown',
 
561
            expected_draft_update_fields=['description_rich_text'])
564
562
 
565
563
    def test_put_with_description_text_type_plain(self):
566
564
        """Testing the PUT review-requests/<id>/draft/ API
572
570
            expected_change_text_type='plain',
573
571
            expected_description_text_type='plain',
574
572
            expected_testing_done_text_type='plain',
575
 
            expected_custom_field_text_type='markdown')
 
573
            expected_custom_field_text_type='markdown',
 
574
            expected_draft_update_fields=['description_rich_text'])
576
575
 
577
576
    def test_put_with_testing_done_text_type_markdown(self):
578
577
        """Testing the PUT review-requests/<id>/draft/ API
584
583
            expected_change_text_type='plain',
585
584
            expected_description_text_type='plain',
586
585
            expected_testing_done_text_type='markdown',
587
 
            expected_custom_field_text_type='markdown')
 
586
            expected_custom_field_text_type='markdown',
 
587
            expected_draft_update_fields=['testing_done_rich_text'])
588
588
 
589
589
    def test_put_with_testing_done_text_type_plain(self):
590
590
        """Testing the PUT review-requests/<id>/draft/ API
596
596
            expected_change_text_type='plain',
597
597
            expected_description_text_type='plain',
598
598
            expected_testing_done_text_type='plain',
599
 
            expected_custom_field_text_type='markdown')
 
599
            expected_custom_field_text_type='markdown',
 
600
            expected_draft_update_fields=['testing_done_rich_text'])
600
601
 
601
602
    def test_put_with_custom_field_text_type_markdown(self):
602
603
        """Testing the PUT review-requests/<id>/draft/ API
622
623
            expected_testing_done_text_type='plain',
623
624
            expected_custom_field_text_type='plain')
624
625
 
 
626
    @webapi_test_template
 
627
    def test_put_with_branch(self):
 
628
        """Testing the PUT <URL> API with branch field"""
 
629
        review_request = self.create_review_request(submitter=self.user,
 
630
                                                    publish=True)
 
631
        ReviewRequestDraft.create(review_request)
 
632
 
 
633
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
634
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
635
 
 
636
        rsp = self.api_put(
 
637
            get_review_request_draft_url(review_request),
 
638
            {
 
639
                'branch': 'new branch',
 
640
            },
 
641
            expected_mimetype=review_request_draft_item_mimetype)
 
642
 
 
643
        self.assertEqual(rsp['stat'], 'ok')
 
644
        self.assertEqual(rsp['draft']['branch'], 'new branch')
 
645
 
 
646
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
647
        self.assertEqual(draft.branch, 'new branch')
 
648
 
 
649
        self.assertFalse(ChangeDescription.save.called)
 
650
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
651
            update_fields=['branch', 'last_updated']))
 
652
 
 
653
    @webapi_test_template
 
654
    def test_put_with_bugs_closed(self):
 
655
        """Testing the PUT <URL> API with bugs_closed field"""
 
656
        review_request = self.create_review_request(submitter=self.user,
 
657
                                                    publish=True)
 
658
        ReviewRequestDraft.create(review_request)
 
659
 
 
660
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
661
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
662
 
 
663
        rsp = self.api_put(
 
664
            get_review_request_draft_url(review_request),
 
665
            {
 
666
                'bugs_closed': '10,20, 300,,',
 
667
            },
 
668
            expected_mimetype=review_request_draft_item_mimetype)
 
669
 
 
670
        self.assertEqual(rsp['stat'], 'ok')
 
671
        self.assertEqual(rsp['draft']['bugs_closed'], ['10', '20', '300'])
 
672
 
 
673
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
674
        self.assertEqual(draft.get_bug_list(), ['10', '20', '300'])
 
675
 
 
676
        self.assertFalse(ChangeDescription.save.called)
 
677
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
678
            update_fields=['bugs_closed', 'last_updated']))
 
679
 
 
680
    @webapi_test_template
 
681
    def test_put_with_changedescription(self):
 
682
        """Testing the PUT <URL> with a change description"""
 
683
        review_request = self.create_review_request(submitter=self.user,
 
684
                                                    publish=True)
 
685
        ReviewRequestDraft.create(review_request)
 
686
 
 
687
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
688
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
689
 
 
690
        changedesc = 'This is a test change description.'
 
691
 
 
692
        rsp = self.api_put(
 
693
            get_review_request_draft_url(review_request),
 
694
            {
 
695
                'changedescription': changedesc,
 
696
            },
 
697
            expected_mimetype=review_request_draft_item_mimetype)
 
698
 
 
699
        self.assertEqual(rsp['stat'], 'ok')
 
700
        self.assertEqual(rsp['draft']['changedescription'], changedesc)
 
701
 
 
702
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
703
        self.assertIsNotNone(draft.changedesc)
 
704
        self.assertEqual(draft.changedesc.text, changedesc)
 
705
 
 
706
        self.assertTrue(ChangeDescription.save.last_called_with(
 
707
            update_fields=['text']))
 
708
        self.assertFalse(ReviewRequestDraft.save.called)
 
709
 
625
710
    def test_put_with_commit_id(self):
626
711
        """Testing the PUT review-requests/<id>/draft/ API with commit_id"""
627
712
        review_request = self.create_review_request(submitter=self.user,
628
713
                                                    publish=True)
 
714
        ReviewRequestDraft.create(review_request)
 
715
 
 
716
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
717
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
718
 
629
719
        commit_id = 'abc123'
630
720
 
631
721
        rsp = self.api_put(
634
724
                'commit_id': commit_id,
635
725
            },
636
726
            expected_mimetype=review_request_draft_item_mimetype)
 
727
 
637
728
        self.assertEqual(rsp['stat'], 'ok')
638
729
        self.assertEqual(rsp['draft']['commit_id'], commit_id)
639
730
        self.assertEqual(rsp['draft']['summary'], review_request.summary)
643
734
        review_request = ReviewRequest.objects.get(pk=review_request.pk)
644
735
        self.assertNotEqual(review_request.commit_id, commit_id)
645
736
 
 
737
        self.assertFalse(ChangeDescription.save.called)
 
738
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
739
            update_fields=['commit_id', 'last_updated']))
 
740
 
646
741
    def test_put_with_commit_id_and_used_in_review_request(self):
647
742
        """Testing the PUT review-requests/<id>/draft/ API with commit_id
648
743
        used in another review request
656
751
        review_request = self.create_review_request(submitter=self.user,
657
752
                                                    publish=True)
658
753
 
659
 
        self.api_put(
 
754
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
755
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
756
 
 
757
        rsp = self.api_put(
660
758
            get_review_request_draft_url(review_request),
661
759
            {
662
760
                'commit_id': commit_id,
663
761
            },
664
762
            expected_status=409)
665
763
 
 
764
        self.assertEqual(rsp['stat'], 'fail')
 
765
        self.assertEqual(rsp['err']['code'], COMMIT_ID_ALREADY_EXISTS.code)
 
766
 
666
767
        review_request = ReviewRequest.objects.get(pk=review_request.pk)
667
 
        self.assertIsNone(review_request.commit_id, None)
 
768
        self.assertIsNone(review_request.commit_id)
 
769
 
 
770
        self.assertFalse(ChangeDescription.save.called)
 
771
        self.assertFalse(ReviewRequestDraft.save.called)
668
772
 
669
773
    def test_put_with_commit_id_and_used_in_draft(self):
670
774
        """Testing the PUT review-requests/<id>/draft/ API with commit_id
677
781
            publish=True)
678
782
        existing_draft = ReviewRequestDraft.create(existing_review_request)
679
783
        existing_draft.commit_id = commit_id
680
 
        existing_draft.save()
 
784
        existing_draft.save(update_fields=('commit_id',))
681
785
 
682
786
        review_request = self.create_review_request(submitter=self.user,
683
787
                                                    publish=True)
684
788
 
685
 
        self.api_put(
 
789
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
790
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
791
 
 
792
        rsp = self.api_put(
686
793
            get_review_request_draft_url(review_request),
687
794
            {
688
795
                'commit_id': commit_id,
689
796
            },
690
797
            expected_status=409)
691
798
 
 
799
        self.assertEqual(rsp['stat'], 'fail')
 
800
        self.assertEqual(rsp['err']['code'], COMMIT_ID_ALREADY_EXISTS.code)
 
801
 
692
802
        review_request = ReviewRequest.objects.get(pk=review_request.pk)
693
 
        self.assertIsNone(review_request.commit_id, None)
 
803
        self.assertIsNone(review_request.commit_id)
 
804
 
 
805
        self.assertFalse(ChangeDescription.save.called)
 
806
        self.assertFalse(ReviewRequestDraft.save.called)
694
807
 
695
808
    def test_put_with_commit_id_empty_string(self):
696
809
        """Testing the PUT review-requests/<id>/draft/ API with commit_id=''"""
697
810
        review_request = self.create_review_request(submitter=self.user,
698
811
                                                    publish=True)
 
812
        ReviewRequestDraft.create(review_request)
 
813
 
 
814
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
815
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
699
816
 
700
817
        rsp = self.api_put(
701
818
            get_review_request_draft_url(review_request),
703
820
                'commit_id': '',
704
821
            },
705
822
            expected_mimetype=review_request_draft_item_mimetype)
 
823
 
706
824
        self.assertEqual(rsp['stat'], 'ok')
707
825
        self.assertIsNone(rsp['draft']['commit_id'])
708
826
 
709
827
        review_request = ReviewRequest.objects.get(pk=review_request.pk)
710
828
        self.assertIsNone(review_request.commit_id)
711
829
 
 
830
        self.assertFalse(ChangeDescription.save.called)
 
831
        self.assertFalse(ReviewRequestDraft.save.called)
 
832
 
712
833
    @add_fixtures(['test_scmtools'])
713
834
    def test_put_with_commit_id_with_update_from_commit_id(self):
714
835
        """Testing the PUT review-requests/<id>/draft/ API with
718
839
        review_request = self.create_review_request(submitter=self.user,
719
840
                                                    repository=repository,
720
841
                                                    publish=True)
 
842
        ReviewRequestDraft.create(review_request)
 
843
 
721
844
        commit_id = 'abc123'
722
845
 
 
846
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
847
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
848
 
723
849
        rsp = self.api_put(
724
850
            get_review_request_draft_url(review_request),
725
851
            {
727
853
                'update_from_commit_id': True,
728
854
            },
729
855
            expected_mimetype=review_request_draft_item_mimetype)
 
856
 
730
857
        self.assertEqual(rsp['stat'], 'ok')
731
858
        self.assertEqual(rsp['draft']['commit_id'], commit_id)
732
859
        self.assertEqual(rsp['draft']['summary'], 'Commit summary')
734
861
 
735
862
        review_request = ReviewRequest.objects.get(pk=review_request.pk)
736
863
        self.assertNotEqual(review_request.commit_id, commit_id)
 
864
        self.assertNotEqual(review_request.description, 'Commit description.')
 
865
        self.assertNotEqual(review_request.summary, 'Commit summary')
 
866
 
 
867
        draft = review_request.get_draft()
 
868
        self.assertEqual(draft.commit_id, commit_id)
 
869
        self.assertEqual(draft.description, 'Commit description.')
 
870
        self.assertEqual(draft.summary, 'Commit summary')
 
871
 
 
872
        self.assertFalse(ChangeDescription.save.called)
 
873
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
874
            update_fields=['commit_id', 'description', 'description_rich_text',
 
875
                           'diffset', 'last_updated', 'summary']))
737
876
 
738
877
    def test_put_with_depends_on(self):
739
878
        """Testing the PUT review-requests/<id>/draft/ API
741
880
        """
742
881
        review_request = self.create_review_request(submitter=self.user,
743
882
                                                    publish=True)
 
883
        ReviewRequestDraft.create(review_request)
744
884
 
745
885
        depends_1 = self.create_review_request(
746
886
            summary='Dependency 1',
749
889
            summary='Dependency 2',
750
890
            publish=True)
751
891
 
 
892
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
893
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
894
 
752
895
        rsp = self.api_put(
753
896
            get_review_request_draft_url(review_request),
754
 
            {'depends_on': '%s, %s' % (depends_1.pk, depends_2.pk)},
 
897
            {
 
898
                'depends_on': '%s, %s,,' % (depends_1.pk, depends_2.pk),
 
899
            },
755
900
            expected_mimetype=review_request_draft_item_mimetype)
756
901
 
757
902
        self.assertEqual(rsp['stat'], 'ok')
768
913
        self.assertEqual(list(depends_1.draft_blocks.all()), [draft])
769
914
        self.assertEqual(list(depends_2.draft_blocks.all()), [draft])
770
915
 
 
916
        self.assertFalse(ChangeDescription.save.called)
 
917
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
918
            update_fields=['last_updated']))
 
919
 
771
920
    @add_fixtures(['test_site'])
772
921
    def test_put_with_depends_on_and_site(self):
773
922
        """Testing the PUT review-requests/<id>/draft/ API
775
924
        """
776
925
        review_request = self.create_review_request(submitter='doc',
777
926
                                                    with_local_site=True)
 
927
        ReviewRequestDraft.create(review_request)
778
928
 
779
929
        self._login_user(local_site=True)
780
930
 
788
938
        # This isn't the review request we want to match.
789
939
        bad_depends = self.create_review_request(id=3, publish=True)
790
940
 
 
941
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
942
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
943
 
791
944
        rsp = self.api_put(
792
945
            get_review_request_draft_url(review_request, self.local_site_name),
793
946
            {'depends_on': '3'},
807
960
        self.assertEqual(list(depends_1.draft_blocks.all()), [draft])
808
961
        self.assertEqual(bad_depends.draft_blocks.count(), 0)
809
962
 
 
963
        self.assertFalse(ChangeDescription.save.called)
 
964
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
965
            update_fields=['last_updated']))
 
966
 
810
967
    def test_put_with_depends_on_invalid_id(self):
811
968
        """Testing the PUT review-requests/<id>/draft/ API
812
969
        with depends_on field and invalid ID
813
970
        """
814
971
        review_request = self.create_review_request(submitter=self.user,
815
972
                                                    publish=True)
 
973
        ReviewRequestDraft.create(review_request)
 
974
 
 
975
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
976
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
816
977
 
817
978
        rsp = self.api_put(
818
979
            get_review_request_draft_url(review_request),
819
 
            {'depends_on': '10000'},
 
980
            {
 
981
                'depends_on': '10000',
 
982
            },
820
983
            expected_status=400)
821
984
 
822
985
        self.assertEqual(rsp['stat'], 'fail')
 
986
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
 
987
        self.assertEqual(rsp['draft']['depends_on'], [])
 
988
        self.assertEqual(rsp['fields'], {
 
989
            'depends_on': ['10000'],
 
990
        })
823
991
 
824
992
        draft = review_request.get_draft()
825
993
        self.assertEqual(draft.depends_on.count(), 0)
826
994
 
 
995
        self.assertFalse(ChangeDescription.save.called)
 
996
        self.assertFalse(ReviewRequestDraft.save.called)
 
997
 
 
998
    @webapi_test_template
 
999
    def test_put_with_summary(self):
 
1000
        """Testing the PUT <URL> API with summary field"""
 
1001
        review_request = self.create_review_request(submitter=self.user,
 
1002
                                                    publish=True)
 
1003
        ReviewRequestDraft.create(review_request)
 
1004
 
 
1005
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1006
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1007
 
 
1008
        rsp = self.api_put(
 
1009
            get_review_request_draft_url(review_request),
 
1010
            {
 
1011
                'summary': 'New summary',
 
1012
            },
 
1013
            expected_mimetype=review_request_draft_item_mimetype)
 
1014
 
 
1015
        self.assertEqual(rsp['stat'], 'ok')
 
1016
        self.assertEqual(rsp['draft']['summary'], 'New summary')
 
1017
 
 
1018
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
1019
        self.assertEqual(draft.summary, 'New summary')
 
1020
 
 
1021
        self.assertFalse(ChangeDescription.save.called)
 
1022
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
1023
            update_fields=['last_updated', 'summary']))
 
1024
 
 
1025
    @webapi_test_template
 
1026
    def test_put_with_summary_with_newline(self):
 
1027
        """Testing the PUT <URL> API with summary field containing newline"""
 
1028
        review_request = self.create_review_request(submitter=self.user,
 
1029
                                                    publish=True)
 
1030
        ReviewRequestDraft.create(review_request)
 
1031
 
 
1032
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1033
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1034
 
 
1035
        rsp = self.api_put(
 
1036
            get_review_request_draft_url(review_request),
 
1037
            {
 
1038
                'summary': 'New summary\nbah',
 
1039
            },
 
1040
            expected_status=400)
 
1041
 
 
1042
        self.assertEqual(rsp['stat'], 'fail')
 
1043
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
 
1044
        self.assertEqual(rsp['draft']['target_groups'], [])
 
1045
        self.assertTrue(rsp['fields'], {
 
1046
            'summary': ["The summary can't contain a newline"],
 
1047
        })
 
1048
 
 
1049
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
1050
        self.assertEqual(draft.summary, 'Test Summary')
 
1051
 
 
1052
        self.assertFalse(ChangeDescription.save.called)
 
1053
        self.assertFalse(ReviewRequestDraft.save.called)
 
1054
 
 
1055
    @webapi_test_template
 
1056
    def test_put_with_target_groups(self):
 
1057
        """Testing the PUT <URL> API with target_groups field"""
 
1058
        group1 = self.create_review_group(name='group1')
 
1059
        group2 = self.create_review_group(name='group2')
 
1060
 
 
1061
        review_request = self.create_review_request(submitter=self.user,
 
1062
                                                    publish=True)
 
1063
        ReviewRequestDraft.create(review_request)
 
1064
 
 
1065
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1066
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1067
 
 
1068
        rsp = self.api_put(
 
1069
            get_review_request_draft_url(review_request),
 
1070
            {
 
1071
                'target_groups': 'group1,group2',
 
1072
            },
 
1073
            expected_mimetype=review_request_draft_item_mimetype)
 
1074
 
 
1075
        self.assertEqual(rsp['stat'], 'ok')
 
1076
        self.assertEqual(
 
1077
            rsp['draft']['target_groups'],
 
1078
            [
 
1079
                {
 
1080
                    'href': 'http://testserver/api/groups/group1/',
 
1081
                    'method': 'GET',
 
1082
                    'title': 'group1',
 
1083
                },
 
1084
                {
 
1085
                    'href': 'http://testserver/api/groups/group2/',
 
1086
                    'method': 'GET',
 
1087
                    'title': 'group2',
 
1088
                },
 
1089
            ])
 
1090
 
 
1091
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
1092
        self.assertEqual(list(draft.target_groups.all()),
 
1093
                         [group1, group2])
 
1094
 
 
1095
        self.assertFalse(ChangeDescription.save.called)
 
1096
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
1097
            update_fields=['last_updated']))
 
1098
 
 
1099
    @add_fixtures(['test_site'])
 
1100
    @webapi_test_template
 
1101
    def test_put_with_target_groups_with_local_site(self):
 
1102
        """Testing the PUT <URL> API with target_groups field and Local Site
 
1103
        draft
 
1104
        """
 
1105
        self.user = self._login_user(local_site=True)
 
1106
 
 
1107
        review_request = self.create_review_request(submitter=self.user,
 
1108
                                                    with_local_site=True,
 
1109
                                                    publish=True)
 
1110
        ReviewRequestDraft.create(review_request)
 
1111
 
 
1112
        local_site = review_request.local_site
 
1113
 
 
1114
        group1 = self.create_review_group(name='group1',
 
1115
                                          local_site=local_site)
 
1116
        group2 = self.create_review_group(name='group2',
 
1117
                                          local_site=local_site)
 
1118
 
 
1119
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1120
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1121
 
 
1122
        rsp = self.api_put(
 
1123
            get_review_request_draft_url(review_request, local_site),
 
1124
            {
 
1125
                'target_groups': 'group1,group2',
 
1126
            },
 
1127
            expected_mimetype=review_request_draft_item_mimetype)
 
1128
 
 
1129
        self.assertEqual(rsp['stat'], 'ok')
 
1130
        self.assertEqual(
 
1131
            rsp['draft']['target_groups'],
 
1132
            [
 
1133
                {
 
1134
                    'href': 'http://testserver/s/local-site-1/'
 
1135
                            'api/groups/group1/',
 
1136
                    'method': 'GET',
 
1137
                    'title': 'group1',
 
1138
                },
 
1139
                {
 
1140
                    'href': 'http://testserver/s/local-site-1/'
 
1141
                            'api/groups/group2/',
 
1142
                    'method': 'GET',
 
1143
                    'title': 'group2',
 
1144
                },
 
1145
            ])
 
1146
 
 
1147
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
1148
        self.assertEqual(list(draft.target_groups.all()),
 
1149
                         [group1, group2])
 
1150
 
 
1151
        self.assertFalse(ChangeDescription.save.called)
 
1152
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
1153
            update_fields=['last_updated']))
 
1154
 
 
1155
    @add_fixtures(['test_site'])
 
1156
    @webapi_test_template
 
1157
    def test_put_with_target_groups_with_local_site_and_global_group(self):
 
1158
        """Testing the PUT <URL> API with target_groups field and Local Site
 
1159
        draft with global group
 
1160
        """
 
1161
        self.user = self._login_user(local_site=True)
 
1162
 
 
1163
        review_request = self.create_review_request(submitter=self.user,
 
1164
                                                    with_local_site=True,
 
1165
                                                    publish=True)
 
1166
        ReviewRequestDraft.create(review_request)
 
1167
 
 
1168
        local_site = review_request.local_site
 
1169
 
 
1170
        self.create_review_group(name='group1', local_site=local_site)
 
1171
        self.create_review_group(name='group2')
 
1172
 
 
1173
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1174
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1175
 
 
1176
        rsp = self.api_put(
 
1177
            get_review_request_draft_url(review_request, local_site),
 
1178
            {
 
1179
                'target_groups': 'group1,group2',
 
1180
            },
 
1181
            expected_status=400)
 
1182
 
 
1183
        self.assertEqual(rsp['stat'], 'fail')
 
1184
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
 
1185
        self.assertEqual(rsp['draft']['target_groups'], [])
 
1186
        self.assertTrue(rsp['fields'], {
 
1187
            'target_groups': ['group2'],
 
1188
        })
 
1189
 
 
1190
        draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
 
1191
        self.assertFalse(draft.target_groups.exists())
 
1192
 
 
1193
        self.assertFalse(ChangeDescription.save.called)
 
1194
        self.assertFalse(ReviewRequestDraft.save.called)
 
1195
 
 
1196
    @webapi_test_template
 
1197
    def test_put_with_target_people_and_invalid_user(self):
 
1198
        """Testing the PUT <URL> API with target_people containing invalid
 
1199
        username
 
1200
        """
 
1201
        review_request = self.create_review_request(submitter=self.user)
 
1202
        draft = ReviewRequestDraft.create(review_request)
 
1203
 
 
1204
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1205
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1206
 
 
1207
        rsp = self.api_put(
 
1208
            get_review_request_draft_url(review_request, None),
 
1209
            {
 
1210
                'target_people': 'invalid'
 
1211
            },
 
1212
            expected_status=INVALID_FORM_DATA.http_status)
 
1213
 
 
1214
        self.assertEqual(rsp['stat'], 'fail')
 
1215
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
 
1216
        self.assertEqual(rsp['fields'], {
 
1217
            'target_people': ['invalid'],
 
1218
        })
 
1219
        self.assertEqual(rsp['draft']['target_people'], [])
 
1220
 
 
1221
        draft = ReviewRequestDraft.objects.get(pk=draft.pk)
 
1222
        self.assertFalse(draft.target_people.exists())
 
1223
 
 
1224
        self.assertFalse(ChangeDescription.save.called)
 
1225
        self.assertFalse(ReviewRequestDraft.save.called)
 
1226
 
 
1227
    @webapi_test_template
 
1228
    def test_put_with_target_people_and_auth_backend_lookup(self):
 
1229
        """Testing the PUT <URL> API with target_people and unknown user
 
1230
        lookup in auth backend
 
1231
        """
 
1232
        def _get_or_create_user(*args, **kwargs):
 
1233
            return User.objects.create(username='backend-user')
 
1234
 
 
1235
        review_request = self.create_review_request(submitter=self.user)
 
1236
        draft = ReviewRequestDraft.create(review_request)
 
1237
 
 
1238
        self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
1239
        self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
 
1240
        self.spy_on(StandardAuthBackend.get_or_create_user,
 
1241
                    call_fake=_get_or_create_user)
 
1242
 
 
1243
        rsp = self.api_put(
 
1244
            get_review_request_draft_url(review_request, None),
 
1245
            {
 
1246
                'target_people': 'backend-user',
 
1247
            },
 
1248
            expected_mimetype=review_request_draft_item_mimetype)
 
1249
 
 
1250
        self.assertEqual(rsp['stat'], 'ok')
 
1251
        self.assertEqual(rsp['draft']['target_people'], [
 
1252
            {
 
1253
                'href': 'http://testserver/api/users/backend-user/',
 
1254
                'method': 'GET',
 
1255
                'title': 'backend-user',
 
1256
            },
 
1257
        ])
 
1258
 
 
1259
        self.assertTrue(StandardAuthBackend.get_or_create_user.called_with(
 
1260
            username='backend-user'))
 
1261
 
 
1262
        draft = ReviewRequestDraft.objects.get(pk=draft.pk)
 
1263
        self.assertEqual(draft.target_people.count(), 1)
 
1264
        self.assertEqual(draft.target_people.get().username, 'backend-user')
 
1265
 
 
1266
        self.assertFalse(ChangeDescription.save.called)
 
1267
        self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
1268
            update_fields=['last_updated']))
 
1269
 
 
1270
    @webapi_test_template
 
1271
    def test_put_with_target_people_and_auth_backend_lookup_error(self):
 
1272
        """Testing the PUT <URL> API with target_people and unknown user
 
1273
        lookup in auth backend errors
 
1274
        """
 
1275
        def _get_or_create_user(*args, **kwargs):
 
1276
            raise Exception()
 
1277
 
 
1278
        self.spy_on(StandardAuthBackend.get_or_create_user,
 
1279
                    call_fake=_get_or_create_user)
 
1280
 
 
1281
        review_request = self.create_review_request(submitter=self.user)
 
1282
        draft = ReviewRequestDraft.create(review_request)
 
1283
 
 
1284
        rsp = self.api_put(
 
1285
            get_review_request_draft_url(review_request, None),
 
1286
            {
 
1287
                'target_people': 'unknown',
 
1288
            },
 
1289
            expected_status=INVALID_FORM_DATA.http_status)
 
1290
 
 
1291
        self.assertEqual(rsp['stat'], 'fail')
 
1292
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
 
1293
        self.assertEqual(rsp['fields'], {
 
1294
            'target_people': ['unknown'],
 
1295
        })
 
1296
        self.assertEqual(rsp['draft']['target_people'], [])
 
1297
 
 
1298
        self.assertTrue(StandardAuthBackend.get_or_create_user.called_with(
 
1299
            username='unknown'))
 
1300
 
 
1301
        draft = ReviewRequestDraft.objects.get(pk=draft.pk)
 
1302
        self.assertFalse(draft.target_people.exists())
 
1303
 
827
1304
    def test_put_with_permission_denied_error(self):
828
1305
        """Testing the PUT review-requests/<id>/draft/ API
829
1306
        with Permission Denied error
879
1356
 
880
1357
    def test_put_publish_with_new_submitter(self):
881
1358
        """Testing the PUT review-requests/<id>/draft/?public=1 API
882
 
        with new submitter"""
 
1359
        with new submitter
 
1360
        """
883
1361
        review_request = self.create_review_request(submitter=self.user,
884
1362
                                                    publish=True)
885
1363
        draft = ReviewRequestDraft.create(review_request)
978
1456
        self._test_put_as_other_user(
979
1457
            self.get_local_site(name=self.local_site_name))
980
1458
 
981
 
    def test_put_find_user_fails(self):
982
 
        """Testing the PUT review-requests/<id>/draft/ API
983
 
        with invalid target_people value
984
 
        """
985
 
        review_request = self.create_review_request(submitter=self.user)
986
 
        ReviewRequestDraft.create(review_request)
987
 
 
988
 
        rsp = self.api_put(
989
 
            get_review_request_draft_url(review_request, None),
990
 
            {
991
 
                'target_people': 'invalid'
992
 
            },
993
 
            expected_status=INVALID_FORM_DATA.http_status)
994
 
        self.assertEqual(rsp['stat'], 'fail')
995
 
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
996
 
        self.assertTrue('target_people' in rsp['fields'])
997
 
 
998
 
    def test_put_find_user_exception(self):
999
 
        """Testing the PUT review-requests/<id>/draft/ API
1000
 
        with _find_user exception
1001
 
        """
1002
 
        def _find_user_fail(*args, **kwargs):
1003
 
            raise Exception()
1004
 
 
1005
 
        self.spy_on(resources.review_request_draft._find_user,
1006
 
                    call_fake=_find_user_fail)
1007
 
 
1008
 
        review_request = self.create_review_request(
1009
 
            submitter=self.user)
1010
 
 
1011
 
        ReviewRequestDraft.create(review_request)
1012
 
 
1013
 
        rsp = self.api_put(
1014
 
            get_review_request_draft_url(review_request, None),
1015
 
            {
1016
 
                'submitter': 'invalid'
1017
 
            },
1018
 
            expected_status=INVALID_FORM_DATA.http_status)
1019
 
        self.assertEqual(rsp['stat'], 'fail')
1020
 
        self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
1021
 
        self.assertTrue('submitter' in rsp['fields'])
1022
 
        self.assertTrue(resources.review_request_draft._find_user.called)
1023
 
 
1024
1459
    def test_put_with_invalid_submitter(self):
1025
1460
        """Testing the PUT review-requests/<id>/draft/ API with an invalid
1026
1461
        submitter
1593
2028
                                  expected_change_text_type,
1594
2029
                                  expected_description_text_type,
1595
2030
                                  expected_testing_done_text_type,
1596
 
                                  expected_custom_field_text_type):
 
2031
                                  expected_custom_field_text_type,
 
2032
                                  expected_changedesc_update_fields=[],
 
2033
                                  expected_draft_update_fields=[]):
1597
2034
        text = '`This` is a **test**'
1598
2035
 
1599
2036
        class CustomField(BaseTextAreaField):
1605
2042
        try:
1606
2043
            review_request = self.create_review_request(submitter=self.user,
1607
2044
                                                        publish=True)
 
2045
            ReviewRequestDraft.create(review_request)
 
2046
 
 
2047
            self.spy_on(ChangeDescription.save, owner=ChangeDescription)
 
2048
            self.spy_on(ReviewRequestDraft.save, owner=ReviewRequestDraft)
1608
2049
 
1609
2050
            rsp = self.api_put(
1610
2051
                get_review_request_draft_url(review_request),
1636
2077
 
1637
2078
            draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
1638
2079
            self.compare_item(draft_rsp, draft)
 
2080
 
 
2081
            self.assertTrue(ChangeDescription.save.last_called_with(
 
2082
                update_fields=sorted(['text'] +
 
2083
                                     expected_changedesc_update_fields)))
 
2084
            self.assertTrue(ReviewRequestDraft.save.last_called_with(
 
2085
                update_fields=sorted(['description', 'extra_data',
 
2086
                                      'last_updated', 'testing_done'] +
 
2087
                                     expected_draft_update_fields)))
1639
2088
        finally:
1640
2089
            fieldset.remove_field(CustomField)
1641
2090