Skip to content

Latest commit

 

History

History
160 lines (104 loc) · 3.89 KB

README.md

File metadata and controls

160 lines (104 loc) · 3.89 KB

Rusty Chess

Rusty Chess is an experimental project showcasing the application of Test-Driven Development (TDD) and Continuous Integration/Continuous Deployment (CI/CD) principles in the development of a chess game using Rust. The project explores how robust testing and automated workflows can streamline development and ensure high-quality software.

Live Demo

Project Goals

The primary objectives of this project are:

  1. Practice TDD in Rust: Applying TDD methodologies to build a chess game from the ground up.
  2. Establish CI/CD Pipelines: Automating the development lifecycle using modern CI/CD practices.
  3. Promote Best Practices: Demonstrating how TDD and CI/CD can be leveraged for efficient and reliable Rust development.

Features

  • Chess Game Implementation:

    • Core chess mechanics developed with a focus on correctness and maintainability.
    • Iterative development driven by comprehensive unit tests.

  • TDD Workflow:

    • Tests written before functionality to ensure a fail-pass-refactor cycle.
    • Strict adherence to the TDD red-green-refactor process.

  • CI/CD Pipeline:

    • Automated pipelines for testing, building, and deployment.
    • Integration with GitHub Actions for continuous feedback and quality assurance.

  • Polymorphic Design for Chess Pieces:

    • Leveraged polymorphism to create a flexible and maintainable system for chess pieces.
    • Each piece inherits from a common base class, allowing consistent behavior while enabling unique functionality.
    • This approach simplifies the addition of new pieces or modifications to existing ones.

Technologies Used

  • Rust: Language used for game development.
  • Cargo: Rust's package manager and build system.
  • GitHub Actions: For CI/CD pipeline automation.

Getting Started

Prerequisites

  • Rust (version X.X or later)
  • Cargo installed

Setup

  1. Clone the repository:

    git clone https://github.com/donedgardo/rusty_chess.git
cd rusty_chess

  2. Build the project:

    cargo build

  3. Run the tests:

    cargo test

Running Tests

Unit tests are the backbone of the development process for Rusty Chess. To execute the tests:

cargo test

The tests include:

  • Game Mechanics: Validations for chess rules and logic.
  • Edge Cases: Coverage for scenarios such as stalemates and checkmates.

CI/CD with GitHub Actions

Pipeline Overview

The GitHub Actions workflow includes:

  1. Code Checkout: Pulls the latest code from the repository.
  2. Build: Ensures the project compiles successfully.
  3. Tests: Runs unit tests to validate functionality.
  4. Deployment: Deploys the application (future enhancement).

Example GitHub Actions Workflow

name: CI/CD Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable

    - name: Build
      run: cargo build --verbose

    - name: Test
      run: cargo test --verbose

Future Enhancements

  • Expand game logic to include advanced chess features such as en passant and pawn promotion.
  • Improve CI/CD pipeline with deployment and notification steps.
  • Explore integration testing with a simple UI or command-line interface.

Contributing

Contributions are welcome! If you have ideas or improvements, feel free to open an issue or submit a pull request.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Acknowledgments

  • Rust community for excellent tooling and documentation.
  • Inspiration from TDD and CI/CD best practices in modern software development.