Add tests for cat-file

Author: C-likethis123

.zed/settings.json

@@ -0,0 +1,20 @@
+{
+  "languages": {
+    "C++": {
+      "format_on_save": "on"
+    }
+  },
+  "lsp": {
+    "clangd": {
+      "binary": {
+        "path": "/usr/bin/clangd",
+        "arguments": [
+          "-log=verbose",
+          "-pretty",
+          "--background-index",
+          "--enable-config"
+        ]
+      }
+    }
+  }
+}

include/parsers/CatfileParser.h

@@ -0,0 +1,29 @@
+#ifndef CATFILEPARSER_H
+#define CATFILEPARSER_H
+
+#include "tclap/CmdLine.h"
+#include <string>
+#include <vector>
+
+class CatfileParser {
+public:
+  static CatfileParser &get();
+  void parse(std::vector<std::string> &args);
+  std::string getType() const;
+  std::string getHash() const;
+
+private:
+  // hides constructors to avoid accidental instantiation
+  CatfileParser();
+  CatfileParser(const CatfileParser &) = delete;
+  CatfileParser &operator=(const CatfileParser &) = delete;
+  CatfileParser(CatfileParser &&) = delete;
+  CatfileParser &operator=(CatfileParser &&) = delete;
+  ~CatfileParser() = default;
+  // data members
+  TCLAP::CmdLine cmd;
+  TCLAP::UnlabeledValueArg<std::string> typeArg;
+  TCLAP::UnlabeledValueArg<std::string> objArg;
+};
+
+#endif // CATFILEPARSER_H

src/commands/cat-file.cpp

@@ -1,36 +1,24 @@
 #include "commands/cat-file.h"
 #include <iostream>
+#include <stdexcept>
 
 #include "object.h"
+#include "parsers/CatfileParser.h"
 #include "repository.h"
-#include "tclap/CmdLine.h"
 
 namespace commands {
 void catfile(std::vector<std::string> &args) {
-  TCLAP::CmdLine cmd("cat-file", ' ', "0.1");
+  CatfileParser &parser = CatfileParser::get();
+  parser.parse(args);
+  std::string type = parser.getType();
+  std::string hash = parser.getHash();
 
-  // defines arguments
-  TCLAP::UnlabeledValueArg<std::string> typeArg("type", "type of object", true,
-                                                "blob", "blob");
-  TCLAP::UnlabeledValueArg<std::string> objArg(
-      "object", "object hash", true, "e6c0a6d3b2ca0dbb3313843238d7e27f63259d3a",
-      "string");
+  std::optional<GitRepository> repo = GitRepository::find();
 
-  cmd.add(typeArg);
-  cmd.add(objArg);
-  cmd.parse(args);
-  std::string &type = typeArg.getValue();
-  std::string &hash = objArg.getValue();
-
-  // process args
-  try {
-    std::optional<GitRepository> repo = GitRepository::find();
-    if (repo) {
-      GitObject *obj = GitObject::read(*repo, GitObject::find(*repo, hash));
-      std::cout << obj->serialise(*repo);
-    }
-  } catch (std::runtime_error &err) {
-    std::cerr << err.what() << "\n";
+  if (!repo) {
+    throw std::runtime_error("No git repository found");
   }
+  GitObject *obj = GitObject::read(*repo, GitObject::find(*repo, hash));
+  std::cout << obj->serialise(*repo);
 }
 } // namespace commands

src/commit.cpp

@@ -21,11 +21,14 @@ std::string GitCommit::serialise(GitRepository &repo) {
      << this->keyValuePairs["author_email"] << "> "
      << this->keyValuePairs["author_unix_timestamp"] << " "
      << this->keyValuePairs["author_timezone"] << "\n";
-  ss << "committer " << this->keyValuePairs["committer_name"] << " "
+  ss << "committer " << this->keyValuePairs["committer_name"] << " <"
      << this->keyValuePairs["committer_email"] << "> "
      << this->keyValuePairs["committer_unix_timestamp"] << " "
      << this->keyValuePairs["committer_timezone"] << "\n";
-  ss << "gpgsig " << this->keyValuePairs["gpgsig"] << "\n\n";
+  if (this->keyValuePairs.find("gpgsig") != this->keyValuePairs.end()) {
+    ss << "gpgsig " << this->keyValuePairs["gpgsig"];
+  }
+  ss << "\n\n";
   ss << this->keyValuePairs["message"];
   return ss.str();
 }

src/parsers/CatfileParser.cpp

@@ -0,0 +1,26 @@
+#include "parsers/CatfileParser.h"
+#include <string>
+#include <vector>
+
+void CatfileParser::parse(std::vector<std::string> &args) {
+  cmd.reset();
+  cmd.parse(args);
+}
+
+std::string CatfileParser::getType() const { return typeArg.getValue(); }
+std::string CatfileParser::getHash() const { return objArg.getValue(); }
+
+CatfileParser &CatfileParser::get() {
+  static CatfileParser instance;
+  return instance;
+}
+
+CatfileParser::CatfileParser()
+    : cmd("cat-file", ' ', "0.1"),
+      typeArg("type", "type of object", true, "blob", "blob"),
+      objArg("object", "object hash", true,
+             "e6c0a6d3b2ca0dbb3313843238d7e27f63259d3a", "string") {
+  cmd.ignoreUnmatched(true);
+  cmd.add(typeArg);
+  cmd.add(objArg);
+}

test.sh

@@ -7,17 +7,17 @@ BUILD_TYPE=${BUILD_TYPE:-Debug}
 #If the environment is specified as "prod", set the build type to Release
 if [ "$1" == "-p" ];
 then
-    BUILD_TYPE=Release 
+    BUILD_TYPE=Release
 fi
 
 #remove old build if any
 if [ -f "app/gyt" ];
-then 
-    rm -rf app/gyt 
+then
+    rm -rf app/gyt
 fi
 
 #Print the selected build type
-echo "Selected build type: $BUILD_TYPE" 
+echo "Selected build type: $BUILD_TYPE"
 echo "Building the project... This will take a while to install dependencies for the first time."
 
 rm -rf ../tests/gitrepo/.git
@@ -30,8 +30,8 @@ cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_EXPORT_COMPILE_COMMANDS=1 -DBUIL
 ninja
 
 # test
-ctest --output-on-failure
+ctest --output-on-failure -R catfile
 
 #symlink - so I can run it like gyt[arguments....]
-sudo rm /usr/local/bin/gyt 
+sudo rm /usr/local/bin/gyt
 sudo ln -s "$(pwd)/app/gyt" /usr/local/bin/gyt

tests/CMakeLists.txt

@@ -1,10 +1,10 @@
-add_executable(tests tests.cpp repository_t.cpp tag_t.cpp object_t.cpp checkout_t.cpp utils/gitreposetup.cpp)
+add_executable(tests tests.cpp repository_t.cpp tag_t.cpp object_t.cpp checkout_t.cpp cat-file.cpp utils/gitreposetup.cpp)
 target_include_directories(tests PUBLIC ../ext)
 
 target_link_libraries(tests PUBLIC boost_libraries repository commands)
-file(COPY ${CMAKE_SOURCE_DIR}/tests/gitrepo 
+file(COPY ${CMAKE_SOURCE_DIR}/tests/gitrepo
      DESTINATION ${CMAKE_BINARY_DIR}/tests)
 
 # allow user to run tests with `make test` or `ctest`
 include(../cmake/Catch.cmake)
-catch_discover_tests(tests)
+catch_discover_tests(tests)

tests/cat-file.cpp

@@ -0,0 +1,65 @@
+#include "commands/cat-file.h"
+#include "catch2/catch.hpp"
+#include "repository.h"
+#include "utils/gitreposetup.h"
+#include <filesystem>
+#include <iostream>
+#include <sstream>
+namespace fs = std::filesystem;
+
+TEST_CASE("catfile command", "[catfile]") {
+  GitRepoSetup gitRepoSetup;
+  SECTION("Valid git catfile command - catfile commit", "catfile commit") {
+    std::vector<std::string> args({"cat-file", "commit", "head"});
+
+    std::stringstream buffer;
+    std::streambuf *oldCout = std::cout.rdbuf();
+    std::cout.rdbuf(buffer.rdbuf());
+    commands::catfile(args);
+    std::cout.rdbuf(oldCout);
+    REQUIRE(buffer.str() ==
+            "tree 19f66fa2b7cba386a1d185449eed1c024d71df25\n"
+            "parent 1723ac93b92db1fc2c28de8e5da814136937f8c6\n"
+            "author Chow Jia Ying <[email protected]> 1747142657 +0800\n"
+            "committer Chow Jia Ying <[email protected]> 1747142657 "
+            "+0800\n\n\n"
+
+            "Test file2\n");
+  }
+  SECTION("Valid git catfile command - catfile a blob", "catfile blob") {
+    std::vector<std::string> args(
+        {"cat-file", "blob", "9daeafb9864cf43055ae93beb0afd6c7d144bfa4"});
+    std::stringstream buffer;
+    std::streambuf *oldCout = std::cout.rdbuf();
+    std::cout.rdbuf(buffer.rdbuf());
+    commands::catfile(args);
+    std::cout.rdbuf(oldCout);
+    REQUIRE_NOTHROW(GitRepository(VALID_GIT_PATH, true));
+    REQUIRE(buffer.str() == "test\n");
+  }
+}
+
+// TEST_CASE("catfile with errors", "[catfile errors]") {
+//   GitRepoSetup gitRepoSetup;
+//   SECTION("Git catfile already exists") {
+//     std::vector<std::string> args({"catfile", "v1.0"});
+//     commands::catfile(args);
+
+//     REQUIRE_NOTHROW(GitRepository(VALID_GIT_PATH, true));
+//     REQUIRE(fs::exists(".git/refs/tags/v1.0"));
+//     REQUIRE(GitRepoSetup::get_file_contents(".git/refs/tags/v1.0") ==
+//             SECOND_COMMIT);
+
+//     std::vector<std::string> args2({"tag", "v1.0"});
+//     REQUIRE_THROWS_WITH(commands::catfile(args2), "tag 'v1.0' already
+//     exists");
+//   }
+//   SECTION("Git tag failed with non-existent commit") {
+//     std::vector<std::string> args({"tag", "v1.0", "nonexistentcommit"});
+//     REQUIRE_NOTHROW(GitRepository(VALID_GIT_PATH, true));
+
+//     REQUIRE_THROWS_WITH(commands::catfile(args),
+//                         "nonexistentcommit: not a valid commit");
+//     REQUIRE(!fs::exists(".git/refs/tags/v1.0"));
+//   }
+// }