def test_createUserObject_unrecognized_src(self):
     d = users.createUserObject(self.master, "Tyler Durden", 'blah')
     def check(_):
         self.assertEqual(self.db.users.users, {})
         self.assertEqual(self.db.users.users_info, {})
     d.addCallback(check)
     return d
示例#2
0
    def test_createUserObject_unrecognized_src(self):
        d = users.createUserObject(self.master, "Tyler Durden", 'blah')

        def check(_):
            self.assertEqual(self.db.users.users, {})
            self.assertEqual(self.db.users.users_info, {})
        d.addCallback(check)
        return d
示例#3
0
    def test_createUserObject_bzr(self):
        yield users.createUserObject(self.master, "Tyler Durden", 'bzr')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='Tyler Durden',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="bzr",
                                   attr_data="Tyler Durden")]})
    def test_createUserObject_cvs(self):
        d = users.createUserObject(self.master, "tdurden", "cvs")

        def check(_):
            self.assertEqual(self.db.users.users, {1: dict(identifier="tdurden", bb_username=None, bb_password=None)})
            self.assertEqual(self.db.users.users_info, {1: [dict(attr_type="cvs", attr_data="tdurden")]})

        d.addCallback(check)
        return d
示例#5
0
    def test_createUserObject_cvs(self):
        yield users.createUserObject(self.master, "tdurden", 'cvs')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='tdurden',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="cvs",
                                   attr_data="tdurden")]})
示例#6
0
    def test_createUserObject_darcs(self):
        yield users.createUserObject(self.master, "*****@*****.**", 'darcs')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='*****@*****.**',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="darcs",
                                   attr_data="*****@*****.**")]})
    def test_createUserObject_darcs(self):
        yield users.createUserObject(self.master, "*****@*****.**", 'darcs')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='*****@*****.**',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="darcs",
                                   attr_data="*****@*****.**")]})
    def test_createUserObject_cvs(self):
        yield users.createUserObject(self.master, "tdurden", 'cvs')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='tdurden',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="cvs",
                                   attr_data="tdurden")]})
    def test_createUserObject_bzr(self):
        yield users.createUserObject(self.master, "Tyler Durden", 'bzr')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='Tyler Durden',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="bzr",
                                   attr_data="Tyler Durden")]})
 def test_createUserObject_darcs(self):
     d = users.createUserObject(self.master, "*****@*****.**", 'darcs')
     def check(_):
         self.assertEqual(self.db.users.users,
                  { 1: dict(identifier='*****@*****.**') })
         self.assertEqual(self.db.users.users_info,
                  { 1: [dict(attr_type="darcs",
                             attr_data="*****@*****.**")]})
     d.addCallback(check)
     return d
 def test_createUserObject_cvs(self):
     d = users.createUserObject(self.master, "tdurden", 'cvs')
     def check(_):
         self.assertEqual(self.db.users.users,
                          { 1: dict(identifier='tdurden') })
         self.assertEqual(self.db.users.users_info,
                          { 1: [dict(attr_type="cvs",
                                     attr_data="tdurden")]})
     d.addCallback(check)
     return d
 def test_createUserObject_bzr(self):
     d = users.createUserObject(self.master, "Tyler Durden", 'bzr')
     def check(_):
         self.assertEqual(self.db.users.users,
                  { 1: dict(identifier='Tyler Durden') })
         self.assertEqual(self.db.users.users_info,
                  { 1: [dict(attr_type="bzr",
                             attr_data="Tyler Durden")]})
     d.addCallback(check)
     return d
    def test_createUserObject_hg(self):
        yield users.createUserObject(self.master,
                                   "Tyler Durden <*****@*****.**>", 'hg')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='Tyler Durden <*****@*****.**>',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="hg",
                                   attr_data="Tyler Durden <*****@*****.**>")]})
示例#14
0
    def test_createUserObject_hg(self):
        yield users.createUserObject(self.master,
                                   "Tyler Durden <*****@*****.**>", 'hg')

        self.assertEqual(self.db.users.users,
                         {1: dict(identifier='Tyler Durden <*****@*****.**>',
                                  bb_username=None, bb_password=None)})
        self.assertEqual(self.db.users.users_info,
                         {1: [dict(attr_type="hg",
                                   attr_data="Tyler Durden <*****@*****.**>")]})
 def test_createUserObject_hg(self):
     d = users.createUserObject(self.master,
                                "Tyler Durden <*****@*****.**>", 'hg')
     def check(_):
         self.assertEqual(self.db.users.users,
                  { 1: dict(identifier='Tyler Durden <*****@*****.**>') })
         self.assertEqual(self.db.users.users_info,
                  { 1: [dict(attr_type="hg",
                             attr_data="Tyler Durden <*****@*****.**>")]})
     d.addCallback(check)
     return d
示例#16
0
    def test_createUserObject_cvs(self):
        d = users.createUserObject(self.master, "tdurden", 'cvs')

        def check(_):
            self.assertEqual(self.db.users.users,
                             {1: dict(identifier='tdurden',
                                      bb_username=None, bb_password=None)})
            self.assertEqual(self.db.users.users_info,
                             {1: [dict(attr_type="cvs",
                                       attr_data="tdurden")]})
        d.addCallback(check)
        return d
示例#17
0
    def test_createUserObject_darcs(self):
        d = users.createUserObject(self.master, "*****@*****.**", 'darcs')

        def check(_):
            self.assertEqual(self.db.users.users,
                             {1: dict(identifier='*****@*****.**',
                              bb_username=None, bb_password=None)})
            self.assertEqual(self.db.users.users_info,
                             {1: [dict(attr_type="darcs",
                                       attr_data="*****@*****.**")]})
        d.addCallback(check)
        return d
 def test_createUserObject_git(self):
     d = users.createUserObject(self.master,
                                "Tyler Durden <*****@*****.**>", 'git')
     def check(_):
         self.assertEqual(self.db.users.users,
                  { 1: dict(identifier='Tyler Durden <*****@*****.**>',
                            bb_username=None, bb_password=None) })
         self.assertEqual(self.db.users.users_info,
                  { 1: [dict(attr_type="git",
                             attr_data="Tyler Durden <*****@*****.**>")]})
     d.addCallback(check)
     return d
示例#19
0
    def test_createUserObject_hg(self):
        d = users.createUserObject(self.master,
                                   "Tyler Durden <*****@*****.**>", 'hg')

        def check(_):
            self.assertEqual(self.db.users.users,
                             {1: dict(identifier='Tyler Durden <*****@*****.**>',
                              bb_username=None, bb_password=None)})
            self.assertEqual(self.db.users.users_info,
                             {1: [dict(attr_type="hg",
                                       attr_data="Tyler Durden <*****@*****.**>")]})
        d.addCallback(check)
        return d
    def test_createUserObject_no_src(self):
        yield users.createUserObject(self.master, "Tyler Durden", None)

        self.assertEqual(self.db.users.users, {})
        self.assertEqual(self.db.users.users_info, {})
    def test_createUserObject_unrecognized_src(self):
        yield users.createUserObject(self.master, "Tyler Durden", 'blah')

        self.assertEqual(self.db.users.users, {})
        self.assertEqual(self.db.users.users_info, {})
示例#22
0
    def addChange(self, files=None, comments=None, author=None, revision=None,
                  when_timestamp=None, branch=None, category=None, revlink=u'',
                  properties=None, repository=u'', codebase=None, project=u'',
                  src=None, _reactor=reactor):
        metrics.MetricCountEvent.log("added_changes", 1)

        if properties is None:
            properties = {}
        # add the source to the properties
        for k in properties:
            properties[k] = (properties[k], u'Change')

        # get a user id
        if src:
            # create user object, returning a corresponding uid
            uid = yield users.createUserObject(self.master,
                                               author, src)
        else:
            uid = None

        if not revlink and revision and repository and callable(self.master.config.revlink):
            # generate revlink from revision and repository using the configured callable
            revlink = self.master.config.revlink(revision, repository) or u''

        if callable(category):
            pre_change = self.master.config.preChangeGenerator(author=author,
                                                               files=files,
                                                               comments=comments,
                                                               revision=revision,
                                                               when_timestamp=when_timestamp,
                                                               branch=branch,
                                                               revlink=revlink,
                                                               properties=properties,
                                                               repository=repository,
                                                               project=project)
            category = category(pre_change)

        # set the codebase, either the default, supplied, or generated
        if codebase is None \
                and self.master.config.codebaseGenerator is not None:
            pre_change = self.master.config.preChangeGenerator(author=author,
                                                               files=files,
                                                               comments=comments,
                                                               revision=revision,
                                                               when_timestamp=when_timestamp,
                                                               branch=branch,
                                                               category=category,
                                                               revlink=revlink,
                                                               properties=properties,
                                                               repository=repository,
                                                               project=project)
            codebase = self.master.config.codebaseGenerator(pre_change)
            codebase = text_type(codebase)
        else:
            codebase = codebase or u''

        # add the Change to the database
        changeid = yield self.master.db.changes.addChange(
            author=author,
            files=files,
            comments=comments,
            revision=revision,
            when_timestamp=epoch2datetime(when_timestamp),
            branch=branch,
            category=category,
            revlink=revlink,
            properties=properties,
            repository=repository,
            codebase=codebase,
            project=project,
            uid=uid,
            _reactor=_reactor)

        # get the change and munge the result for the notification
        change = yield self.master.data.get(('changes', str(changeid)))
        change = copy.deepcopy(change)
        self.produceEvent(change, 'new')

        # log, being careful to handle funny characters
        msg = u"added change with revision %s to database" % (revision,)
        log.msg(msg.encode('utf-8', 'replace'))

        defer.returnValue(changeid)
示例#23
0
    def addChange(
        self,
        files=None,
        comments=None,
        author=None,
        revision=None,
        when_timestamp=None,
        branch=None,
        category=None,
        revlink=u"",
        properties={},
        repository=u"",
        codebase=None,
        project=u"",
        src=None,
        _reactor=reactor,
    ):
        metrics.MetricCountEvent.log("added_changes", 1)

        # add the source to the properties
        for k in properties:
            properties[k] = (properties[k], u"Change")

        # get a user id
        if src:
            # create user object, returning a corresponding uid
            uid = yield users.createUserObject(self.master, author, src)
        else:
            uid = None

        # set the codebase, either the default, supplied, or generated
        if codebase is None and self.master.config.codebaseGenerator is not None:
            pre_change = {
                "author": author,
                "files": files,
                "comments": comments,
                "revision": revision,
                "when_timestamp": when_timestamp,
                "branch": branch,
                "category": category,
                "revlink": revlink,
                "properties": properties,
                "repository": repository,
                "project": project,
                "codebase": None,
                # 'uid': uid, -- not in data API yet?
            }
            codebase = self.master.config.codebaseGenerator(pre_change)
            codebase = unicode(codebase)
        else:
            codebase = codebase or u""

        # add the Change to the database
        changeid = yield self.master.db.changes.addChange(
            author=author,
            files=files,
            comments=comments,
            revision=revision,
            when_timestamp=epoch2datetime(when_timestamp),
            branch=branch,
            category=category,
            revlink=revlink,
            properties=properties,
            repository=repository,
            codebase=codebase,
            project=project,
            uid=uid,
            _reactor=_reactor,
        )

        # get the change and munge the result for the notification
        change = yield self.master.data.get(("changes", str(changeid)))
        change = copy.deepcopy(change)
        self.produceEvent(change, "new")

        # log, being careful to handle funny characters
        msg = u"added change with revision %s to database" % (revision,)
        log.msg(msg.encode("utf-8", "replace"))

        defer.returnValue(changeid)
示例#24
0
    def addChange(self, files=None, comments=None, author=None, revision=None,
                  when_timestamp=None, branch=None, category=None, revlink=u'',
                  properties={}, repository=u'', codebase=None, project=u'',
                  src=None, _reactor=reactor):
        metrics.MetricCountEvent.log("added_changes", 1)

        # add the source to the properties
        for k in properties:
            properties[k] = (properties[k], u'Change')

        # get a user id
        if src:
            # create user object, returning a corresponding uid
            uid = yield users.createUserObject(self.master,
                                               author, src)
        else:
            uid = None

        # set the codebase, either the default, supplied, or generated
        if codebase is None \
                and self.master.config.codebaseGenerator is not None:
            pre_change = {
                'author': author,
                'files': files,
                'comments': comments,
                'revision': revision,
                'when_timestamp': when_timestamp,
                'branch': branch,
                'category': category,
                'revlink': revlink,
                'properties': properties,
                'repository': repository,
                'project': project,
                'codebase': None,
                # 'uid': uid, -- not in data API yet?
            }
            codebase = self.master.config.codebaseGenerator(pre_change)
            codebase = unicode(codebase)
        else:
            codebase = codebase or u''

        # add the Change to the database
        changeid = yield self.master.db.changes.addChange(
            author=author,
            files=files,
            comments=comments,
            revision=revision,
            when_timestamp=epoch2datetime(when_timestamp),
            branch=branch,
            category=category,
            revlink=revlink,
            properties=properties,
            repository=repository,
            codebase=codebase,
            project=project,
            uid=uid,
            _reactor=_reactor)

        # get the change and munge the result for the notification
        change = yield self.master.data.get(('changes', str(changeid)))
        change = copy.deepcopy(change)
        self.produceEvent(change, 'new')

        # log, being careful to handle funny characters
        msg = u"added change with revision %s to database" % (revision,)
        log.msg(msg.encode('utf-8', 'replace'))

        defer.returnValue(changeid)
示例#25
0
    def addChange(self, files=None, comments=None, author=None, revision=None,
                  when_timestamp=None, branch=None, category=None, revlink=u'',
                  properties=None, repository=u'', codebase=None, project=u'',
                  src=None, _reactor=reactor):
        metrics.MetricCountEvent.log("added_changes", 1)

        if properties is None:
            properties = {}
        # add the source to the properties
        for k in properties:
            properties[k] = (properties[k], u'Change')

        # get a user id
        if src:
            # create user object, returning a corresponding uid
            uid = yield users.createUserObject(self.master,
                                               author, src)
        else:
            uid = None

        if not revlink and revision and repository and callable(self.master.config.revlink):
            # generate revlink from revision and repository using the configured callable
            revlink = self.master.config.revlink(revision, repository) or u''

        if callable(category):
            pre_change = self.master.config.preChangeGenerator(author=author,
                                                               files=files,
                                                               comments=comments,
                                                               revision=revision,
                                                               when_timestamp=when_timestamp,
                                                               branch=branch,
                                                               revlink=revlink,
                                                               properties=properties,
                                                               repository=repository,
                                                               project=project)
            category = category(pre_change)

        # set the codebase, either the default, supplied, or generated
        if codebase is None \
                and self.master.config.codebaseGenerator is not None:
            pre_change = self.master.config.preChangeGenerator(author=author,
                                                               files=files,
                                                               comments=comments,
                                                               revision=revision,
                                                               when_timestamp=when_timestamp,
                                                               branch=branch,
                                                               category=category,
                                                               revlink=revlink,
                                                               properties=properties,
                                                               repository=repository,
                                                               project=project)
            codebase = self.master.config.codebaseGenerator(pre_change)
            codebase = text_type(codebase)
        else:
            codebase = codebase or u''

        # add the Change to the database
        changeid = yield self.master.db.changes.addChange(
            author=author,
            files=files,
            comments=comments,
            revision=revision,
            when_timestamp=epoch2datetime(when_timestamp),
            branch=branch,
            category=category,
            revlink=revlink,
            properties=properties,
            repository=repository,
            codebase=codebase,
            project=project,
            uid=uid,
            _reactor=_reactor)

        # get the change and munge the result for the notification
        change = yield self.master.data.get(('changes', str(changeid)))
        change = copy.deepcopy(change)
        self.produceEvent(change, 'new')

        # log, being careful to handle funny characters
        msg = u"added change with revision %s to database" % (revision,)
        log.msg(msg.encode('utf-8', 'replace'))

        defer.returnValue(changeid)
示例#26
0
    def test_createUserObject_unrecognized_src(self):
        yield users.createUserObject(self.master, "Tyler Durden", 'blah')

        self.assertEqual(self.db.users.users, {})
        self.assertEqual(self.db.users.users_info, {})
示例#27
0
    def addChange(self, who=None, files=None, comments=None, author=None,
            isdir=None, is_dir=None, revision=None, when=None,
            when_timestamp=None, branch=None, category=None, revlink='',
            properties={}, repository='', project='', src=None):
        """
        Add a change to the buildmaster and act on it.

        This is a wrapper around L{ChangesConnectorComponent.addChange} which
        also acts on the resulting change and returns a L{Change} instance.

        Note that all parameters are keyword arguments, although C{who},
        C{files}, and C{comments} can be specified positionally for
        backward-compatibility.

        @param author: the author of this change
        @type author: unicode string

        @param who: deprecated name for C{author}

        @param files: a list of filenames that were changed
        @type branch: list of unicode strings

        @param comments: user comments on the change
        @type branch: unicode string

        @param is_dir: deprecated

        @param isdir: deprecated name for C{is_dir}

        @param revision: the revision identifier for this change
        @type revision: unicode string

        @param when_timestamp: when this change occurred, or the current time
          if None
        @type when_timestamp: datetime instance or None

        @param when: deprecated name and type for C{when_timestamp}
        @type when: integer (UNIX epoch time) or None

        @param branch: the branch on which this change took place
        @type branch: unicode string

        @param category: category for this change (arbitrary use by Buildbot
        users)
        @type category: unicode string

        @param revlink: link to a web view of this revision
        @type revlink: unicode string

        @param properties: properties to set on this change
        @type properties: dictionary with string keys and simple values
        (JSON-able).  Note that the property source is I{not} included
        in this dictionary.

        @param repository: the repository in which this change took place
        @type repository: unicode string

        @param project: the project this change is a part of
        @type project: unicode string

        @param src: source of the change (vcs or other)
        @type src: string

        @returns: L{Change} instance via Deferred
        """
        metrics.MetricCountEvent.log("added_changes", 1)

        # handle translating deprecated names into new names for db.changes
        def handle_deprec(oldname, old, newname, new, default=None,
                          converter = lambda x:x):
            if old is not None:
                if new is None:
                    log.msg("WARNING: change source is using deprecated "
                            "addChange parameter '%s'" % oldname)
                    return converter(old)
                raise TypeError("Cannot provide '%s' and '%s' to addChange"
                                % (oldname, newname))
            if new is None:
                new = default
            return new

        author = handle_deprec("who", who, "author", author)
        is_dir = handle_deprec("isdir", isdir, "is_dir", is_dir,
                                default=0)
        when_timestamp = handle_deprec("when", when,
                                "when_timestamp", when_timestamp,
                                converter=epoch2datetime)

        # add a source to each property
        for n in properties:
            properties[n] = (properties[n], 'Change')

        d = defer.succeed(None)
        if src:
            # create user object, returning a corresponding uid
            d.addCallback(lambda _ : users.createUserObject(self, author, src))

        # add the Change to the database
        d.addCallback(lambda uid :
                          self.db.changes.addChange(author=author, files=files,
                                          comments=comments, is_dir=is_dir,
                                          revision=revision,
                                          when_timestamp=when_timestamp,
                                          branch=branch, category=category,
                                          revlink=revlink, properties=properties,
                                          repository=repository, project=project,
                                          uid=uid))

        # convert the changeid to a Change instance
        d.addCallback(lambda changeid :
                self.db.changes.getChange(changeid))
        d.addCallback(lambda chdict :
                changes.Change.fromChdict(self, chdict))

        def notify(change):
            msg = u"added change %s to database" % change
            log.msg(msg.encode('utf-8', 'replace'))
            # only deliver messages immediately if we're not polling
            if not self.config.db['db_poll_interval']:
                self._change_subs.deliver(change)
            return change
        d.addCallback(notify)
        return d
示例#28
0
    def test_createUserObject_no_src(self):
        yield users.createUserObject(self.master, "Tyler Durden", None)

        self.assertEqual(self.db.users.users, {})
        self.assertEqual(self.db.users.users_info, {})