Esempio n. 1
0
    def test_comments_delete(self, object_factory):
        """Test if {} deleted along with comments."""
        obj = object_factory()
        comment_first = factories.CommentFactory()
        comment_second = factories.CommentFactory()
        comment_ids = (comment_first.id, comment_second.id)
        relationship_first = factories.RelationshipFactory(
            source=comment_first, destination=obj)
        relationship_second = factories.RelationshipFactory(
            source=obj, destination=comment_second)
        rel_ids = (relationship_first.id, relationship_second.id)

        result = self.api.delete(obj)
        self.assertEqual(result.status_code, 200)
        for rel_id in rel_ids:
            relationship = all_models.Relationship.query.get(rel_id)
            self.assertEqual(relationship, None)

        for comment_id in comment_ids:
            comment = all_models.Comment.query.get(comment_id)
            self.assertEqual(comment, None)

            delete_revision = all_models.Revision.query.filter(
                all_models.Revision.resource_id == comment_id,
                all_models.Revision.resource_type == "Comment",
                all_models.Revision.action == "deleted").first()
            self.assertNotEqual(delete_revision, None)
Esempio n. 2
0
    def setup_objects(self):
        """Sets up all the objects needed by the tests"""
        objects = self.objects
        # Program
        objects['program'] = program = factories.ProgramFactory(
            title="A Program")
        # Controls
        objects['controls'] = controls = [
            factories.ControlFactory(title="My First Control"),
            factories.ControlFactory(title="My Second Control")
        ]

        # Audit
        objects['audit'] = audit = factories.AuditFactory(
            program=objects['program'],
            access_control_list=[{
                "ac_role_id": self.audit_roles['Auditors'].id,
                "person": {
                    "id": self.people['created_auditor'].id
                },
            }, {
                "ac_role_id":
                self.audit_roles['Audit Captains'].id,
                "person": {
                    "id": self.people['created_captain'].id
                },
            }])
        factories.RelationshipFactory(source=program, destination=audit)
        # Assessment template
        objects['assessment_template'] = factories.AssessmentTemplateFactory()

        # Assessment
        objects['assessment'] = factories.AssessmentFactory(audit=audit)

        # Snapshot
        objects['snapshots'] = self._create_snapshots(audit, controls)
        for snapshot in objects['snapshots']:
            factories.RelationshipFactory(source=audit, destination=snapshot)

        # Issues
        objects['issue'] = factories.IssueFactory(
            access_control_list=[{
                "ac_role_id": self.issue_roles['Admin'].id,
                "person": {
                    "id": self.people['issue_admin'].id
                },
            }])

        # Comments
        objects['comment'] = factories.CommentFactory()
        objects['issue_comment'] = factories.CommentFactory()

        # Documents
        objects['issue_document'] = factories.DocumentFactory()

        # Evidence
        objects['evidence'] = factories.EvidenceUrlFactory()
    def test_adding_comment_to_issue(self, update_issue_mock,
                                     url_builder_mock):
        """Test adding comment to issue."""
        iti = factories.IssueTrackerIssueFactory(
            enabled=True, issue_tracked_obj=factories.IssueFactory())
        comment = factories.CommentFactory(description="test comment")

        expected_result = {
            "comment":
            u"A new comment is added by 'Example User' to the 'Issue': "
            u"'test comment'.\nUse the following to link to get more "
            u"information from the GGRC 'Issue'. Link - "
            u"http://issue_url.com"
        }

        with mock.patch.object(settings, "ISSUE_TRACKER_ENABLED", True):
            self.api.post(
                all_models.Relationship, {
                    "relationship": {
                        "source": {
                            "id": iti.issue_tracked_obj.id,
                            "type": "Issue"
                        },
                        "destination": {
                            "id": comment.id,
                            "type": "comment"
                        },
                        "context": None
                    },
                })
        url_builder_mock.assert_called_once()
        update_issue_mock.assert_called_with(iti.issue_id, expected_result)
Esempio n. 4
0
  def test_last_comment_value(self):
    """Test proper value in last_comment field"""
    with factories.single_commit():
      c_task = wf_factories.CycleTaskGroupObjectTaskFactory()
      c_task_id = c_task.id
      comment_1 = factories.CommentFactory(description=factories.random_str())
      comment_2 = factories.CommentFactory(description=factories.random_str())
      comment_2_id = comment_2.id
      factories.RelationshipFactory(source=c_task, destination=comment_1)
      factories.RelationshipFactory(source=c_task, destination=comment_2)

    self.compute_attributes()
    comment_2 = all_models.Comment.query.get(comment_2_id)
    c_task = all_models.CycleTaskGroupObjectTask.query.get(c_task_id)

    self.assertEqual(c_task.last_comment, comment_2.description)
Esempio n. 5
0
 def _setup_comment(self):
   """Crate and map comment"""
   with factories.single_commit():
     comment = factories.CommentFactory(description="Hey!")
     parent = db.session.query(self.parent.__class__).get(self.parent_id)
     factories.RelationshipFactory(source=parent, destination=comment)
   return comment.id
Esempio n. 6
0
  def read_document_comment(self):
    """Read comments mapped to document"""
    doc_id = self._setup_document()
    document = all_models.Document.query.get(doc_id)
    with factories.single_commit():
      comment = factories.CommentFactory(description=factories.random_str())
      factories.RelationshipFactory(source=document, destination=comment)

    query_request_data = [
        {
            "fields": [],
            "filters": {
                "expression": {
                    "object_name": "Document",
                    "op": {
                        "name": "relevant"
                    },
                    "ids": [document.id]
                }
            },
            "object_name": "Comment",
        }
    ]

    response = self.api.send_request(
        self.api.client.post, data=query_request_data, api_link="/query"
    )
    return response
    def test_preconditions_failed_with_present_mandatory_comment(self):
        """No preconditions failed if comment required by CA is present."""
        ca = CustomAttributeMock(
            self.assessment,
            attribute_type="Dropdown",
            dropdown_parameters=("foo,comment_required", "0,1"),
            value=None,  # the value is made with generator to store revision too
        )
        _, ca.value = GENERATOR.generate_custom_attribute_value(
            custom_attribute_id=ca.definition.id,
            attributable=self.assessment,
            attribute_value="comment_required",
        )
        comment = factories.CommentFactory(
            assignee_type="Assessor",
            description="Mandatory comment",
        )
        comment.custom_attribute_revision_upd({
            "custom_attribute_revision_upd": {
                "custom_attribute_value": {
                    "id": ca.value.id,
                },
            },
        })
        factories.RelationshipFactory(
            source=self.assessment,
            destination=comment,
        )

        preconditions_failed = self.assessment.preconditions_failed

        self.assertEqual(preconditions_failed, False)
        self.assertFalse(ca.value.preconditions_failed)
Esempio n. 8
0
    def read_comments(self):
        """Read comments mapped to evidence"""
        evidence = all_models.Evidence.query.get(self.evidence_id)
        with factories.single_commit():
            comment = factories.CommentFactory(
                description=factories.random_str())
            factories.RelationshipFactory(source=evidence, destination=comment)

        query_request_data = [{
            "fields": [],
            "filters": {
                "expression": {
                    "object_name": "Evidence",
                    "op": {
                        "name": "relevant"
                    },
                    "ids": [evidence.id]
                }
            },
            "object_name": "Comment",
        }]

        response = self.api.send_request(self.api.client.post,
                                         data=query_request_data,
                                         api_link="/query")
        return response
Esempio n. 9
0
    def read_comment(self):
        """Read comments mapped to cycle task"""
        cycle_task = all_models.CycleTaskGroupObjectTask.query.get(
            self.cycle_task_id)
        with factories.single_commit():
            comment = factories.CommentFactory(
                description=factories.random_str())
            factories.RelationshipFactory(source=cycle_task,
                                          destination=comment)

        query_request_data = [{
            "fields": [],
            "filters": {
                "expression": {
                    "object_name": "CycleTaskGroupObjectTask",
                    "op": {
                        "name": "relevant"
                    },
                    "ids": [cycle_task.id]
                }
            },
            "object_name": "Comment",
        }]

        response = self.api.send_request(self.api.client.post,
                                         data=query_request_data,
                                         api_link="/query")
        return response
Esempio n. 10
0
    def test_handle_one_comment(self, send_email_mock):
        """Test handling of mapped comment."""
        with factories.single_commit():
            person = factories.PersonFactory(email="*****@*****.**")
            obj = factories.ProductFactory(title="Product1")
            comment = factories.CommentFactory(
                description=u"One <a href=\"mailto:[email protected]\"></a>", )
            comment.modified_by_id = person.id
            comment.created_at = datetime.datetime(2018, 1, 10, 7, 31, 42)
            url = urljoin(get_url_root(), utils.view_url_for(obj))

        people_mentions.handle_comment_mapped(obj, [comment])
        expected_title = (u"[email protected] mentioned you "
                          u"on a comment within Product1")
        expected_body = (
            u"[email protected] mentioned you on a comment within Product1 "
            u"at 01/09/2018 23:31:42 PST:\n"
            u"One <a href=\"mailto:[email protected]\"></a>\n")
        body = settings.EMAIL_MENTIONED_PERSON.render(
            person_mention={
                "comments": [expected_body],
                "url": url,
            })
        send_email_mock.assert_called_once_with(u"*****@*****.**",
                                                expected_title, body)
Esempio n. 11
0
    def test_handle_task_comment(self, send_email_mock):
        """Test handling of mapped comment to cycle task."""
        with factories.single_commit():
            person = factories.PersonFactory(email="*****@*****.**")
            obj = wf_factories.CycleTaskGroupObjectTaskFactory(
                slug=u"TSK-1",
                title=u"task1",
            )
            comment = factories.CommentFactory(
                description=u"One <a href=\"mailto:[email protected]\"></a>", )
            comment.modified_by_id = person.id
            comment.created_at = datetime.datetime(2018, 1, 10, 7, 31, 42)
            url = "http://localhost/dashboard#!task&query=%22task%20slug%22%3DTSK-1"

        people_mentions.handle_comment_mapped(obj, [comment])
        expected_title = (u"[email protected] mentioned you "
                          u"on a comment within task1")
        expected_body = (
            u"[email protected] mentioned you on a comment within task1 "
            u"at 01/09/2018 23:31:42 PST:\n"
            u"One <a href=\"mailto:[email protected]\"></a>\n")
        body = settings.EMAIL_MENTIONED_PERSON.render(
            person_mention={
                "comments": [expected_body],
                "url": url,
            })
        send_email_mock.assert_called_once_with(u"*****@*****.**",
                                                expected_title, body)
  def test_adding_comment_to_issue(self, update_issue_mock, url_builder_mock):
    """Test adding comment to issue."""
    role = all_models.Role.query.filter(
        all_models.Role.name == "Administrator"
    ).one()
    with factories.single_commit():
      client_user = factories.PersonFactory(name="Test User")
      rbac_factories.UserRoleFactory(role=role, person=client_user)
    self.api.set_user(client_user)
    self.client.get("/login")
    iti = factories.IssueTrackerIssueFactory(
        enabled=True,
        issue_tracked_obj=factories.IssueFactory()
    )
    comment = factories.CommentFactory(description="test comment")
    expected_result = {
        "comment":
            params_builder.BaseIssueTrackerParamsBuilder.COMMENT_TMPL.format(
                author=client_user.name,
                comment=comment.description,
                model="Issue",
                link="http://issue_url.com",
            )
    }

    with mock.patch.object(settings, "ISSUE_TRACKER_ENABLED", True):
      self.api.post(all_models.Relationship, {
          "relationship": {
              "source": {"id": iti.issue_tracked_obj.id, "type": "Issue"},
              "destination": {"id": comment.id, "type": "comment"},
              "context": None
          },
      })
    url_builder_mock.assert_called_once()
    update_issue_mock.assert_called_with(iti.issue_id, expected_result)
Esempio n. 13
0
  def setup_objects(self):
    """Sets up all the objects needed by the tests"""
    objects = self.objects
    # Program
    objects['program'] = factories.ProgramFactory(title="A Program")
    # Controls
    objects['controls'] = controls = [
        factories.ControlFactory(title="My First Control"),
        factories.ControlFactory(title="My Second Control")
    ]

    # Audit
    objects['audit'] = audit = factories.AuditFactory(
        program=objects['program'],
        access_control_list=[{
            "ac_role": self.audit_roles['Auditors'],
            "person": self.people['created_auditor']
        }, {
            "ac_role": self.audit_roles['Audit Captains'],
            "person": self.people['created_captain']
        }]
    )
    # Assessment template
    objects['assessment_template'] = factories.AssessmentTemplateFactory()

    # Assessment
    objects['assessment'] = factories.AssessmentFactory(audit=audit)

    # Snapshot
    objects['snapshots'] = self._create_snapshots(audit, controls)

    # Issues
    objects['issue'] = factories.IssueFactory(
        access_control_list=[{
            "ac_role": self.issue_roles['Admin'],
            "person": self.people['issue_admin']
        }]
    )

    # Comments
    objects['comment'] = factories.CommentFactory()
    objects['issue_comment'] = factories.CommentFactory()

    # Documents
    objects['document'] = factories.DocumentFactory()
    objects['issue_document'] = factories.DocumentFactory()
 def test_search_by_new_comment(self):
     """Filter by added new comment and old comment exists"""
     slugs = [self.assessment.slug]
     desc = "321"
     new_comment = factories.CommentFactory(description=desc)
     factories.RelationshipFactory(source=new_comment,
                                   destination=self.assessment)
     self.assert_slugs("comment", self.comment.description, slugs)
     self.assert_slugs("comment", desc, slugs)
Esempio n. 15
0
 def test_filter_by_task_comment(self):
   """Test filter by comments"""
   task_id = self.generate_tasks_for_cycle(4)[0]
   comment_text = "123"
   task = all_models.CycleTaskGroupObjectTask.query.filter(
       all_models.CycleTaskGroupObjectTask.id == task_id
   ).one()
   comment = ggrc_factories.CommentFactory(description=comment_text)
   ggrc_factories.RelationshipFactory(source=task, destination=comment)
   self.assert_slugs("task comment", comment_text, [task.slug])
Esempio n. 16
0
 def test_handle_empty_comment(self, send_email_mock):
     """Test handling of mapped comment with no mention."""
     with factories.single_commit():
         person = factories.PersonFactory(email="*****@*****.**")
         obj = factories.ProductFactory(title="Product2")
         comment = factories.CommentFactory(description=u"test")
         comment.created_at = datetime.datetime(2018, 1, 10, 7, 31, 42)
         comment.modified_by_id = person.id
     people_mentions.handle_comment_mapped(obj, [comment])
     send_email_mock.assert_not_called()
Esempio n. 17
0
 def setUp(self):
   super(TestCollection, self).setUp()
   self.clear_data()
   self.expected_ids = []
   assessments = [factories.AssessmentFactory() for _ in range(10)]
   random.shuffle(assessments)
   for idx, assessment in enumerate(assessments):
     comment = factories.CommentFactory(description=str(idx))
     factories.RelationshipFactory(source=assessment, destination=comment)
     self.expected_ids.append(assessment.id)
Esempio n. 18
0
 def setUp(self):
   super(TestExport, self).setUp()
   self.client.get("/login")
   self.headers = {
       'Content-Type': 'application/json',
       "X-Requested-By": "GGRC",
       "X-export-view": "blocks",
   }
   extr_comment = factories.CommentFactory(description="bad_desc")
   extr_assessment = factories.AssessmentFactory()
   db.engine.execute(
       'update assessments set '
       'updated_at = "2010-10-10", '
       'created_at = "2010-10-10";'
   )
   factories.RelationshipFactory(source=extr_assessment,
                                 destination=extr_comment)
   self.comment = factories.CommentFactory(description="123")
   self.assessment = factories.AssessmentFactory()
   self.rel = factories.RelationshipFactory(source=self.comment,
                                            destination=self.assessment)
Esempio n. 19
0
  def test_ca_cleanup_on_obj_delete(self):
    """Test cleaning of fulltext and attributes tables on obj delete"""
    with factories.single_commit():
      for _ in range(2):
        c_task = wf_factories.CycleTaskGroupObjectTaskFactory()
        comment = factories.CommentFactory(
            description=factories.random_str()
        )
        factories.RelationshipFactory(source=c_task, destination=comment)

    self.compute_attributes()

    c_task = all_models.CycleTaskGroupObjectTask.query.first()

    last_comment_records = self.get_model_fulltext(
        "CycleTaskGroupObjectTask", "last_comment", [c_task.id]
    )
    last_comment_attrs = self.get_model_ca(
        "CycleTaskGroupObjectTask",
        [c_task.id]
    )
    self.assertEqual(last_comment_records.count(), 1)
    self.assertEqual(last_comment_attrs.count(), 1)

    response = self.api.delete(c_task)
    self.assert200(response)

    last_comment_records = self.get_model_fulltext(
        "CycleTaskGroupObjectTask", "last_comment", [c_task.id]
    )

    last_comment_attrs = self.get_model_ca(
        "CycleTaskGroupObjectTask",
        [c_task.id]
    )
    self.assertEqual(last_comment_attrs.count(), 0)
    self.assertEqual(last_comment_records.count(), 0)

    # Check that other records weren't affected
    task_ids = [task.id for task in
                all_models.CycleTaskGroupObjectTask.query.all()]

    last_comment_records = self.get_model_fulltext(
        "CycleTaskGroupObjectTask", "last_comment", task_ids
    )
    last_comment_attrs = self.get_model_ca(
        "CycleTaskGroupObjectTask",
        task_ids,
    )

    self.assertEqual(last_comment_records.count(), 1)
    self.assertEqual(last_comment_attrs.count(), 1)
    def test_preconditions_failed_with_changed_value(self):
        """Preconditions failed and comment invalidated on update to CAV."""
        ca = CustomAttributeMock(
            self.assessment,
            attribute_type="Dropdown",
            dropdown_parameters=("foo,comment_required", "0,1"),
            value=None,  # the value is made with generator to store revision too
        )
        _, ca.value = GENERATOR.generate_custom_attribute_value(
            custom_attribute_id=ca.definition.id,
            attributable=self.assessment,
            attribute_value="comment_required",
        )
        comment = factories.CommentFactory(
            assignee_type="Assessor",
            description="Mandatory comment",
        )
        comment.custom_attribute_revision_upd({
            "custom_attribute_revision_upd": {
                "custom_attribute_value": {
                    "id": ca.value.id,
                },
            },
        })
        factories.RelationshipFactory(
            source=self.assessment,
            destination=comment,
        )

        # new CA value not requiring comment
        self.assessment.custom_attribute_values = [{
            "attribute_value":
            "foo",
            "custom_attribute_id":
            ca.definition.id,
        }]
        GENERATOR.api.modify_object(self.assessment, {})

        # new CA value requiring comment; the old comment should be considered
        # invalid
        self.assessment.custom_attribute_values = [{
            "attribute_value":
            "comment_required",
            "custom_attribute_id":
            ca.definition.id,
        }]
        GENERATOR.api.modify_object(self.assessment, {})

        preconditions_failed = self.assessment.preconditions_failed

        self.assertEqual(preconditions_failed, True)
Esempio n. 21
0
    def test_comment_ordering(self):
        """Check ordering for comment"""
        with factories.single_commit():
            cgot = wf_factories.CycleTaskGroupObjectTaskFactory()
            comment1 = factories.CommentFactory(description="comment 1",
                                                created_at=datetime.datetime(
                                                    2017, 1, 1, 7, 31, 32))
            comment2 = factories.CommentFactory(description="comment 2",
                                                created_at=datetime.datetime(
                                                    2017, 1, 1, 7, 31, 42))
            factories.RelationshipFactory(source=comment1, destination=cgot)
            factories.RelationshipFactory(source=comment2, destination=cgot)

        query_request_data = [{
            u"object_name":
            u"Comment",
            u"filters": {
                u"expression": {
                    u"object_name": u"CycleTaskGroupObjectTask",
                    u"op": {
                        u"name": u"relevant"
                    },
                    u"ids": [cgot.id]
                }
            },
            u"order_by": [{
                u"name": u"created_at",
                u"desc": True
            }]
        }]
        resp = self.api.send_request(self.api.client.post,
                                     data=query_request_data,
                                     api_link="/query")
        self.assertEqual(2, resp.json[0]["Comment"]["count"])
        self.assertEqual("comment 2",
                         resp.json[0]["Comment"]["values"][0]["description"])
        self.assertEqual("comment 1",
                         resp.json[0]["Comment"]["values"][1]["description"])
Esempio n. 22
0
    def test_person_mentioned_create(self, send_email_mock, *_):
        """Test that a user with authorized domain is created when mentioned."""
        with factories.single_commit():
            obj = factories.ProductFactory(title="Product6")
            comment = factories.CommentFactory(
                description=u"One <a href=\"mailto:[email protected]"
                u"\"></a>", )
            comment.created_at = datetime.datetime(2018, 1, 10, 7, 31, 42)

        people_mentions.handle_comment_mapped(obj, [comment])
        person = all_models.Person.query.filter_by(
            email="*****@*****.**").first()
        self.assertIsNotNone(person)
        send_email_mock.assert_called_once()
Esempio n. 23
0
    def test_relation_comment_posted(self, send_email_mock):
        """Test sending mention email after posting a relationship to comment."""
        with factories.single_commit():
            author_person = factories.PersonFactory(email="*****@*****.**")
            factories.PersonFactory(email="*****@*****.**")
            obj = factories.ProductFactory(title="Product3")
            obj_id = obj.id
            comment = factories.CommentFactory(
                description=
                u"One <a href=\"mailto:[email protected]\"></a>", )
            comment_id = comment.id
            comment.created_at = datetime.datetime(2018, 07, 10, 8, 31, 42)
            comment.modified_by_id = author_person.id
            url = urljoin(get_url_root(), utils.view_url_for(obj))

        author_person = all_models.Person.query.filter_by(
            email="*****@*****.**").one()
        api = api_helper.Api()
        api.set_user(author_person)

        response = api.post(
            all_models.Relationship, {
                "relationship": {
                    "source": {
                        "id": obj_id,
                        "type": obj.type,
                    },
                    "destination": {
                        "id": comment_id,
                        "type": comment.type
                    },
                    "context": None
                },
            })
        self.assertEqual(response.status_code, 201)

        expected_title = (u"[email protected] mentioned you on "
                          u"a comment within Product3")
        expected_body = (
            u"[email protected] mentioned you on a comment within Product3 "
            u"at 07/10/2018 01:31:42 PDT:\n"
            u"One <a href=\"mailto:[email protected]\"></a>\n")
        body = settings.EMAIL_MENTIONED_PERSON.render(
            person_mention={
                "comments": [expected_body],
                "url": url,
            })
        send_email_mock.assert_called_once_with(u"*****@*****.**",
                                                expected_title, body)
Esempio n. 24
0
 def test_status_unchanged(self):
     """Test auto status isn't change after add comment action"""
     assessment = factories.AssessmentFactory()
     comment = factories.CommentFactory()
     response = self.api.put(assessment, {
         "actions": {
             "add_related": [{
                 "id": comment.id,
                 "type": "Comment",
             }]
         }
     })
     self.assert200(response)
     self.assertEqual(response.json["assessment"]["status"],
                      all_models.Assessment.START_STATE)
Esempio n. 25
0
 def test_remove_comment(self):
   """Test remove comment action."""
   assessment = factories.AssessmentFactory()
   comment = factories.CommentFactory(description="123")
   rel_id = factories.RelationshipFactory(source=assessment,
                                          destination=comment).id
   response = self.api.put(assessment, {"actions": {"remove_related": [
       {
           "id": comment.id,
           "type": "Comment",
       }
   ]}})
   self.assert200(response)
   relationship = all_models.Relationship.query.get(rel_id)
   self.assertIsNone(relationship)
Esempio n. 26
0
    def test_local_user_create_external_relationship(self):
        """Test that local user can't create external relationships"""
        with factories.single_commit():
            program = factories.ProgramFactory()
            comment = factories.CommentFactory()

        response = self.api.client.post(
            self.REL_URL,
            data=self.build_relationship_json(program,
                                              comment,
                                              is_external=True),
            headers=self.HEADERS)
        rel = all_models.Relationship.query.first()

        self.assert400(response)
        self.assertIsNone(rel)
    def test_filter_by_task_comment(self, cycle_count, task_count):
        """Test filter cycles by task comments."""
        task_cycle_filter = self.generate_tasks_for_cycle(
            cycle_count, task_count)
        filter_params = {}
        for task_id, slug in task_cycle_filter.iteritems():
            task = all_models.CycleTaskGroupObjectTask.query.filter(
                all_models.CycleTaskGroupObjectTask.id == task_id).one()
            comment_text = "comment for task # {}".format(task_id)
            comment = ggrc_factories.CommentFactory(description=comment_text)
            ggrc_factories.RelationshipFactory(source=task,
                                               destination=comment)
            filter_params[comment_text] = slug

        for comment_text, slug in filter_params.iteritems():
            self.assertCycles("task comment", comment_text, [slug])
Esempio n. 28
0
  def test_adding_comment_to_issue(self, update_issue_mock):
    """Test not adding comment to issue when issue tracker disabled."""
    iti = factories.IssueTrackerIssueFactory(
        enabled=False,
        issue_tracked_obj=factories.IssueFactory()
    )
    comment = factories.CommentFactory(description="test comment")

    with mock.patch.object(settings, "ISSUE_TRACKER_ENABLED", True):
      self.api.post(all_models.Relationship, {
          "relationship": {
              "source": {"id": iti.issue_tracked_obj.id, "type": "Issue"},
              "destination": {"id": comment.id, "type": "comment"},
              "context": None
          },
      })
    update_issue_mock.assert_not_called()
Esempio n. 29
0
 def test_order_by_test(self, desc):
   """Order by fultext attr"""
   expected_ids = []
   with factories.single_commit():
     assessments = [factories.AssessmentFactory() for _ in range(10)]
   random.shuffle(assessments)
   with factories.single_commit():
     for idx, assessment in enumerate(assessments):
       comment = factories.CommentFactory(description=str(idx))
       factories.RelationshipFactory(source=assessment, destination=comment)
       expected_ids.append(assessment.id)
   query = self._make_query_dict(
       "Assessment", order_by=[{"name": "comment", "desc": desc}]
   )
   if desc:
     expected_ids = expected_ids[::-1]
   results = self._get_first_result_set(query, "Assessment", "values")
   self.assertEqual(expected_ids, [i['id'] for i in results])
  def test_adding_comment_to_assessment(self, desc, mocked_update_issue):
    """Test adding comment with blank lines in the end."""
    with mock.patch.object(
        assessment_integration.AssessmentTrackerHandler,
        '_is_tracker_enabled',
        return_value=True
    ):
      iti = factories.IssueTrackerIssueFactory(
          enabled=True,
          component_id="11111",
          hotlist_id="222222",
          issue_type="PROCESS",
          issue_priority="P2",
          issue_severity="S2"
      )
      iti_title = iti.title
      iti_issue_id = iti.issue_id
      asmt = iti.issue_tracked_obj
      comment = factories.CommentFactory(description=desc)
      self.api.put(asmt, {
          "actions": {"add_related": [{"id": comment.id,
                                       "type": "Comment"}]},
      })

    tracker_handler = assessment_integration.AssessmentTrackerHandler()
    asmt = db.session.query(models.Assessment).get(asmt.id)
    builder_class = params_builder.BaseIssueTrackerParamsBuilder
    expected_comment = builder_class.COMMENT_TMPL.format(
        author=None,
        comment="test comment",
        model="Assessment",
        link=tracker_handler._get_assessment_page_url(asmt),
    )
    kwargs = {'status': 'ACCEPTED',
              'component_id': 11111,
              'severity': "S2",
              'title': iti_title,
              'hotlist_ids': [222222],
              'priority': "P2",
              'comment': expected_comment}
    mocked_update_issue.assert_called_once_with(iti_issue_id, kwargs)