About Checking the Homeworks on Local

[Ermanas]

Hello,

I would like to ask more general question about homework checking. As fas as I understand, in the github actions setup on the homeworks repo homeworks/.github/workflows/check-homework.yml triggered by the pull request. I'm pretty satisfied with it. I simply commit and open up a PR and then I see my mistakes, then fix it with new commits. Also we can discuss on this PR page with the people. After the test are satisfied I can merge the PR.

I'm curious how it's done with the real life projects. Is this the best practice or should we run the test on our local? For example I can try different approaches and I might like to see what would be the result without messing up on opening up a PR.

Or maybe I get it wrong and the github actions is a general testing method which is related with the other components of the software and I should create my own unit tests for my program not the github actions?

Also even I can run them locally, it is modifying the wiki page for example. I don't want to mess with it as well. Because it's not only effecting the single branch but the wiki on the main repository page. Maybe I might not run the whole pipeline but the necessary ones only. I don't know.

Maybe it's whole another topic but I'm just a little bit confused. Also I pretty happy that homeworks and this checking method let me to deal with these and do a research about it.

---

Note: I checked it online and encountered with a repository about it. What they wrote on the readme is exactly what I tought. I'm sharing the first part of their description.

---

Act Repository

"Think globally, act locally"

Run your GitHub Actions locally! Why would you want to do this? Two reasons:

• Fast Feedback - Rather than having to commit/push every time you want to test out the changes you are making to your .github/workflows/ files (or for any changes to embedded GitHub actions), you can use act to run the actions locally. The environment variables and filesystem are all configured to match what GitHub provides.
• Local Task Runner - I love make. However, I also hate repeating myself. With act, you can use the GitHub Actions defined in your .github/workflows/ to replace your Makefile!

[niosus]

A good question @Ermanas and the one I did not think to answer preemptively 😅

First of all, the gist of checking code goes along these lines:

• Implement something along with tests (see video on tests for details 😉)
• Run the tests locally
• Run any relevant examples locally
• Submit code to the server and ideally create a PR which should trigger an automatic check (that we of course have to configure one way or another), usually called CI (continuous integration). Various CI systems are implemented in different ways, some trigger on commits, some on PRs but the idea is the same - they exist to not let us commit code that is not working into git or any other version control system
• Once the CI passes, we merge the code into the main branch

That's the theory. In my own experience, I always run the unit and integration tests locally with language-specific frameworks, like ctest when using CMake, or bazel test when using bazel or pytest for Python. I usually do this from the terminal. In companies it is common to have custom bash or python scripts that implement a sequence of operations to be run to test that the code works as expected. These are then also called from whichever CI system is used. When using GitHub we can use GitHub Actions, on Gitlab there is Gitlab CI, but there are third party solutions like Circle CI or Jenkins etc. There are many. Long story short, they end up calling a script in some environment that runs some tests or code examples.

Now we come to the CI I use here for testing student homeworks. It is much more complex than the usual setup as it has to handle comparing the student homework with the correct solutions that all have to be stored somewhere. It also generates a markdown file that gets uploaded to the PR and to the wiki. These steps are usually not really needed in real projects and are only here for the convenience of the students.

If you want to be sure that the code runs as expected, just build it locally, test it locally and then upload. The only issues popping up on the CI side should be related with the CI-specific setup and are usually issues that I introduced one way or another 😅

Does this all make sense? Please do not hesitate to ask more questions if something is unclear!

[Ermanas]

Thank you for your detailed answer. My takeaway from your answer is,

1. Write your unit tests
2. Put it into CI on your local if it's existed
3. Open up a PR

I guess only the critic or some additional things will be discussed in the PR page with the team then it'll be merged with the main branch. Now things are more clear, at first I though that I should use the homework_checker repository on my local to check my homework before the PR and I couldn't get that how I'm gonna do it 😃

By the way I messed with the spaces a little 😄

[niosus]

Yeah, very close.

Basically, it would be:

1. Write unit tests and new code
2. Run local tests and scripts. These are usually not called CI - that name is usually used for things happening on some remote server upon committing code
3. Push the code to the branch, triggering the CI
4. If not created yet, create a PR
5. Repeat until all issues are fixed

As for the discussion on the PR there are different views on this. Generally speaking the process is called a "review", or "PR review" and is needed to mostly catch readability and logic errors as well as to check that the tests make sense. Basically everything that we cannot easily check automatically. Also, if you ask me, it is completely normal to have many commits in a PR. It is important to give them meaningful names and to squash all of them into one commit per PR with a good meaningful name in the end.

I also want to mention that some people think that running the code in question is also part of the PR review process but I don't agree with this. To me, a PR review only concerns stuff we cannot check automatically and we can run code automatically.

Finally, just to make sure I spell it out, no, you don't have to use the homework checker locally, it is only designed for a way to check homeworks upon uploading them to GitHub. 😅 Sorry if this is a bit confusing.

[Ermanas]

Great! It's more solid now in my mind, thank you 🙏