Web 应用程序开发流程 - 版本控制、错误跟踪、单元测试、部署

发布于 2024-07-16 00:53:26 字数 613 浏览 6 评论 0原文

描述您用于开发不太高级别的 Web 应用程序的流程,重点是 VC、错误跟踪、QA、单元测试、部署和其他类似的内容(减去规划/客户端通信方面的内容)。

我是这个领域的新手,所以我的粗略示例(阅读:没有使用过这个过程)无疑有点不对劲,可以这么说 - 指出它的缺陷,以便我可以学习。

例如。

  1. 在本地SVN服务器上创建项目存储库。
  2. 为 DNS 映射创建批处理/shell 脚本。
  3. 检查项目,开始处理本地工作副本。
  4. 开发功能作为分支。
  5. 使用 Mantis 跟踪错误(链接通过 SVN 集成提交错误(不知道是否存在))。
  6. 边走边记录。
  7. 在分支上进行质量检查。
  8. 稳定后合并到主干。
  9. 单元测试?
  10. 当功能实现且稳定时提交到存储库。
  11. 将版本复制到存储库中的标签。 例如。 /project/tags/rel-123/
  12. 使用 Phing 上传到临时服务器。 (有人可以准确说明除了“测试”之外,临时服务器的用途吗?)
  13. 使用 Phing 准备实时站点以进行更新、设置数据库/部署等。

Describe the process you use to develop web applications at a not-so-high level, focusing on VC, bug tracking, QA, unit testing, deployment and anything else similar (minus the planning/client communication side of things).

I'm new in this area, so my rough example (read: haven't used this process) is no doubt abit off, so to speak - point out it's flaws so I can learn.

Eg.

  1. Create project repository on local SVN server.
  2. Create batch/shell scripts for DNS mappings.
  3. Check out project, begin work on local working copy.
  4. Develop features as branches.
  5. Track bugs with Mantis (link commits to bugs through it's SVN integration (no idea if that exists)).
  6. Document as you go.
  7. Do QA on branch.
  8. Merge to trunk when stable.
  9. Unit Testing?
  10. Commit to repository when feature is implemented and stable.
  11. Copy releases to tags in repository. Eg. /project/tags/rel-123/
  12. Use Phing to upload to staging server. (Could someone please clarify exactly what a staging server is used for beyond 'testing'?)
  13. Use Phing to prep live site for update, set up DB/deploy, etc.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

被你宠の有点坏 2024-07-23 00:53:26
  1. 创建/签出 HEAD 版本(“主分支”)
  2. 开发代码并至少每天与主分支同步 开发
  3. 完成后,编写并运行单元测试
  4. 通过代码审查并向主分支提交代码/更改
  5. 让持续构建器在主分支上运行所有单元测试和系统/集成测试
  6. 准备好后,挑选修订并将其集成到 QA 分支
  7. 运行系统和集成测试,修复报告的错误或根据需要回滚; 这将重复步骤 4-7
  8. 在 QA 签核后,将 QA 更改集成到发布分支
  9. 在发布分支上运行单元测试、系统/集成测试
  10. 部署到生产并运行健全性测试。

登台服务器是尽可能最新的生产环境的副本。 在我当前的项目中,我们能够保持每个版本彼此独立,因此我们的“登台服务器”是我们的生产服务器,只是从不同的 URL 访问。

注释和差异:

根据项目的大小,所有步骤都有一些变化。 您的项目越大,从樱桃采摘和环境分离中获得的好处就越大。 在较小的项目中,这些可能只是时间消耗,并且经常被忽略或绕过。

澄清一下,有一个开发堆栈、QA 堆栈和登台堆栈。 根据您的项目规模,质量检查可能正在分阶段,生产可能正在分阶段,或其某种组合。 开发和 QA 堆栈的分离是最重要的之一。

在上述步骤中,我假设代码和相关数据都已进行版本控制或跟踪。 拥有考虑控制数据的发布和构建过程使得发布变得非常非常容易。

在中小型项目中,可能有也可能没有发布分支; 这取决于代码更改的频率。 此外,根据代码更改的频率和项目的大小,您可以将完整的 QA 分支集成到发布分支,或者挑选特定的修订版本来集成到发布分支。

FWIW,我发现“迁移脚本”没有什么价值。 它们始终是一次性脚本,几乎没有重用,并且使回滚变得很痛苦。 我认为,让应用程序向后兼容要容易得多。 在几次发布之后(当回滚是可笑的时候),如果有必要,应该进行数据清理。

  1. Create/checkout HEAD version ("main branch")
  2. Develop code and sync with the main branch -at least- daily
  3. After development is done, write and run unit tests
  4. Go through code review and submit code/changes to the main branch
  5. Let continuous builder run all unit tests and system/integration tests on main branch
  6. When ready, cherry pick revisions and integrate them to the QA branch
  7. Run system and integration tests, fix reported bugs, or rollback as necessary; this repeats steps 4-7
  8. After QA signoff, integrate QA change to release branch
  9. Run unit tests, system/integration tests on release branch
  10. Deploy to production and run sanity tests.

A staging server is a copy of your production environment that is as up-to-date as possible. On my current project, we're able to keep each release independent from each other, so our "staging server" is our production server, just accessed from a different url.

Notes and discreprencies:

All of the steps have some variation depending on the size of your project. The larger your project, the better the benefit from cherry picking and environment separation. In smaller projects, these can just be time sinks and are often ignored or bypassed.

To clarify, there is a Development stack, QA stack, and Staging stack. Depending on your project size, QA might be staging, Production might be staging, or some combination thereof. The separation of the Dev and QA stacks is the most important one.

In the steps above, I'm assuming both code and relevant data is versioned or tracked. Having a release and build process that takes control data into account makes a release very, very easy.

In a small-medium sized project, there may or may not be a release branch; it depends on the frequency of code change. Also, depending on the frequency of code change and size of your project, you may integrate the full QA branch to the Release branch, or cherry pick specific revisions to integrate to the release branch.

FWIW, I've found "migration scripts" to be of little value. They're always a one-off script with little reuse and make rollbacks a pain in the ass. Its much easier, I would argue better, to have the application backwards-compatible. After a few releases (when a rollback is a laughable), data cleanup should be done, if necessary.

一杆小烟枪 2024-07-23 00:53:26

非常粗略地:

  1. 在 SVN 中创建存储库
  2. 检查本地工作副本到开发人员环境
  3. 频繁更新/提交更改
  4. 使用自定义部署脚本从 SVN 主干部署到
  5. 阶段 阶段 QA 测试,报告 Mantis 中的错误
  6. 开发人员修复错误,标记为已解决
  7. 重新部署到阶段
  8. QA 测试错误,如果修复的
  9. QA 完成则关闭,进行回归测试
  10. 使用自定义部署脚本部署到生产环境
  11. 进行一点舞蹈

我们还为未来的版本或功能创建分支。 这些最终会合并到主干中。

我们使数据库结构与部署期间执行的自定义数据库比较工具保持同步。

Very roughly:

  1. Create repository in SVN
  2. Checking local working copy to developer environment
  3. Update/commit changes frequently
  4. Deploy to stage from SVN trunk using custom deploy script
  5. QA tests on stage, reports bugs in Mantis
  6. Developers fix bugs, mark as resolved
  7. Re-deploy to stage
  8. QA tests bugs, closes if fixed
  9. QA is finished, do regression testing
  10. Deploy to production using custom deploy script
  11. Do a little dance

We also create branches for future versions or features. These eventually get merged into the trunk.

We keep our db structures synchronized with a custom db comparison tool that is executed during the deploys.

小矜持 2024-07-23 00:53:26

老帖子,但有趣的问题!

现在在我的公司:

  1. 创建一个新的 Github 存储库
  2. 在本地配置 Jenkins
  3. 克隆
  4. 启动分支
  5. 开发并添加测试(服务器、客户端和 e2e)
  6. 提交每个步骤,并获取 + 变基以保持分支同步
  7. 准备好后,将分支推送到服务器:预提交检查 lint 并进行测试,如果不正常则进行阻止
  8. 为分支创建拉取请求
  9. 为“绿色”或“损坏的测试”
  10. 这里,jenkins 自动在分支上运行测试,并直接在拉取请求中将其标记 最后 2 位同事审查拉取请求并修复他们的发现(回到步骤 5)
  11. 当一切呈绿色并且 2 位同事都同意时,最后一位同事合并拉取请求
  12. 删除服务器上的分支
  13. 准备好后,推送新版本
  14. 立即获取最新版本部署在测试平台上
  15. QA 验证引入的更正和功能(如果有问题,返回 5)
  16. (TODO) 部署到具有与生产相同参数的预产品
  17. 部署到生产
  18. 就引入的错误向用户道歉;)并报告它们在问题管理器中
  19. 问题管理器重启周期中报告它们
  20. 获取功能请求并在步骤 2 的

Old post, but interesting question !

At my company now :

  1. Create a new Github repo
  2. Configure Jenkins
  3. Clone locally
  4. Start a branch
  5. Develop and add tests (server, client and e2e)
  6. Commit for every step, and fetch + rebase to keep the branch in sync
  7. When ready, push the branch to the server : a pre-commit check lint and tests and block if not ok
  8. Create a pull request for the branch
  9. Here, jenkins automatically runs tests on the branch and flag it as "green" or "broken tests" directly in the pull request
  10. Have at last 2 colleagues review the pull request and fix their findings (back to step 5)
  11. When everything green and 2 colleagues have agreed, the last one merges the pull request
  12. Delete the branch on server
  13. When ready, push a new version
  14. Latest version get immediately deployed on a testing platform
  15. QA validate the corrections and features introduced (back to 5 if problem)
  16. (TODO) deploy to a pre-prod with identical parameters than the production
  17. Deploy to production
  18. Go apologize to users for the bugs introduced ;) and report them in the issue manager
  19. get feature requests and report them in the issue manager
  20. restart cycle at step 2
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文