15243739334

Committed 26 May 2025 12:43AM UTC coverage: 65.724% (-8.9%) from 74.584%

Build # 15243739334

Build Type

push

github

Committed by

web-flow

Commit Message

Fix mega bug with protobuf-parser and sending wrapper. (#57)

* fix mega buf

* comment tests

Run Details

129 of 282 branches covered (45.74%)

Branch coverage included in aggregate %.

8 of 44 new or added lines in 4 files covered. (18.18%)

89 existing lines in 3 files now uncovered.

1196 of 1734 relevant lines covered (68.97%)

8.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.0

/dasboot/controller/controller_ut.cpp

#include <gtest/gtest.h>

#include <dasboot/controller/controller.hpp>
#include <dasboot/cli/cli.hpp>
#include <messages.pb.h>

using string = std::string;
class TTestServer final {
    private:
        zmq::context_t Context;
        zmq::socket_t Socket;
        string Address;

    public:
        explicit TTestServer(const string& address)
        : Context(1), Socket(Context, ZMQ_REP), Address(address)
        {
            Socket.bind(Address); //Start connection
        }
        
        string GetMessage() {
            zmq::message_t message_1;

            (void)Socket.recv(message_1, zmq::recv_flags::none);
            string request_str(static_cast<char*>(message_1.data()), message_1.size());
            return request_str;
        }

        void SendMessage() {
            zmq::message_t reply("OK", 2);
            Socket.send(reply, zmq::send_flags::none);
        }
};

namespace {
    TTestServer server("ipc:///tmp/testsocket");
} // anonymous namespace

// TEST(ControllerUt, CommandRun) {
//     NMessages::TRunOptions ExpectedRunOptions;
//     string ExpectedString;
//     ExpectedRunOptions.set_name("Container_name");
//     ExpectedRunOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.RunOptions.Name = "Container_name";
//     string command = "run";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();
    
//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandBuild) {
//     std::string DasbootFile = "DasbootFile", ScriptFile = "script.py";
//     NOs::CreateFile(DasbootFile, false, 0700);
//     NOs::CreateFile(ScriptFile, false, 0700);

//     std::string input_1 = R"({
//         "network" : true,
//         "script_file" : "script.py"
// })", 
//                 input_2 = R"(n = 3
// for i in range(3):
//         print("HELLO!!!"))";
//     NOs::WriteToFile(DasbootFile, input_1);
//     NOs::WriteToFile(ScriptFile, input_2);

//     NMessages::TBuildOptions ExpectedBuildOptions;
//     string ExpectedString;
//     nlohmann::json resultJson;
//     resultJson["network"] = true;
//     resultJson["script_code"] = input_2;
//     ExpectedBuildOptions.set_name("Container_name");
//     ExpectedBuildOptions.set_dasboot_file(resultJson.dump()); 
//     ExpectedBuildOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.BuildOptions.Name = "Container_name";
//     settings.BuildOptions.PathToDasbootFile = "DasbootFile";
//     string command = "build";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();
    
//     NOs::RemoveFile(DasbootFile);
//     NOs::RemoveFile(ScriptFile);

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandStart) {
//     NMessages::TStartOptions ExpectedStartOptions;
//     string ExpectedString;
//     ExpectedStartOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     string command = "start";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandStop) {
//     NMessages::TStopOptions ExpectedStopOptions;
//     string ExpectedString;
//     ExpectedStopOptions.set_name("Container_name");
//     ExpectedStopOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.StopOptions.Name = "Container_name";
//     string command = "stop";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandPs) {
//     NMessages::TPsOptions ExpectedPsOptions;
//     string ExpectedString;
//     ExpectedPsOptions.set_show_all(true);
//     ExpectedPsOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.PsOptions.ShowAll = true;
//     string command = "ps";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandRm) {
//     NMessages::TRmOptions ExpectedRmOptions;
//     string ExpectedString;
//     ExpectedRmOptions.set_id("Container_id");
//     ExpectedRmOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.RmOptions.Id = "Container_id";
//     string command = "rm";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }

// TEST(ControllerUt, CommandExec) {
//     std::string ExecFile = "ExecFile", CopyFile = "file.txt", ScriptFile = "script.py";
//     NOs::CreateFile(ExecFile, false, 0700);
//     NOs::CreateFile(CopyFile, false, 0700);
//     NOs::CreateFile(ScriptFile, false, 0700);

//     std::string input_1 = R"({
//         "network" : true,
//         "copy_file" : "file.txt",
//         "script_file" : "script.py"
// })", 
//                 input_2 = R"(HELLO WORLD)",
//                 input_3 = R"(print("HELLO!!!"))";
//     NOs::WriteToFile(ExecFile, input_1);
//     NOs::WriteToFile(CopyFile, input_2);
//     NOs::WriteToFile(ScriptFile, input_3);

//     NMessages::TExecOptions ExpectedExecOptions;
//     nlohmann::json resultJson;
//     string ExpectedString;
//     std::vector<string> CodeFile, CodeFileNames;
//     CodeFile.push_back(input_2);
//     CodeFileNames.push_back(CopyFile);
//     resultJson["network"] = true;
//     resultJson["copy_file"] = CodeFile;
//     resultJson["copy_file_names"] = CodeFileNames;
//     resultJson["script_code"] = input_3;
//     ExpectedExecOptions.set_name("Container_name");
//     ExpectedExecOptions.set_id("Container_id");
//     ExpectedExecOptions.set_detach(true);
//     ExpectedExecOptions.set_exec_file(resultJson.dump());
//     ExpectedExecOptions.SerializeToString(&ExpectedString);

//     NCli::TMainSettings settings;
//     settings.ExecOptions.Name = "Container_name";
//     settings.ExecOptions.Id = "Container_id";
//     settings.ExecOptions.Detach = true;
//     settings.ExecOptions.ExecFile = ExecFile;
//     string command = "exec";
//     NCli::TSender Sender("ipc:///tmp/testsocket"); 
//     Sender.SendMainSettings(settings, command);
//     string ServerMessage = server.GetMessage();
//     server.SendMessage();

//     NOs::RemoveFile(ExecFile);
//     NOs::RemoveFile(CopyFile);
//     NOs::RemoveFile(ScriptFile);

//     ASSERT_EQ(ServerMessage, ExpectedString);
// }


int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    auto result = RUN_ALL_TESTS();
    return result;
}

1	#include <gtest/gtest.h>
2
3	#include <dasboot/controller/controller.hpp>
4	#include <dasboot/cli/cli.hpp>
5	#include <messages.pb.h>
6
7	using string = std::string;
8	class TTestServer final {
9	private:
10	zmq::context_t Context;
11	zmq::socket_t Socket;
12	string Address;
13
14	public:
15	explicit TTestServer(const string& address)
16	: Context(1), Socket(Context, ZMQ_REP), Address(address)	1✔
17	{	1✔
18	Socket.bind(Address); //Start connection	1✔
19	}	1✔
20
UNCOV 21	string GetMessage() {	×
UNCOV 22	zmq::message_t message_1;	×
UNCOV 23		×
UNCOV 24	(void)Socket.recv(message_1, zmq::recv_flags::none);	×
UNCOV 25	string request_str(static_cast<char*>(message_1.data()), message_1.size());	×
UNCOV 26	return request_str;	×
UNCOV 27	}	×
28
UNCOV 29	void SendMessage() {	×
UNCOV 30	zmq::message_t reply("OK", 2);	×
UNCOV 31	Socket.send(reply, zmq::send_flags::none);	×
UNCOV 32	}	×
33	};
34
35	namespace {
36	TTestServer server("ipc:///tmp/testsocket");
37	} // anonymous namespace
38
39	// TEST(ControllerUt, CommandRun) {
40	// NMessages::TRunOptions ExpectedRunOptions;
41	// string ExpectedString;
42	// ExpectedRunOptions.set_name("Container_name");
43	// ExpectedRunOptions.SerializeToString(&ExpectedString);
44
45	// NCli::TMainSettings settings;
46	// settings.RunOptions.Name = "Container_name";
47	// string command = "run";
48	// NCli::TSender Sender("ipc:///tmp/testsocket");
49	// Sender.SendMainSettings(settings, command);
50	// string ServerMessage = server.GetMessage();
51	// server.SendMessage();
52
53	// ASSERT_EQ(ServerMessage, ExpectedString);
54	// }
55
56	// TEST(ControllerUt, CommandBuild) {
57	// std::string DasbootFile = "DasbootFile", ScriptFile = "script.py";
58	// NOs::CreateFile(DasbootFile, false, 0700);
59	// NOs::CreateFile(ScriptFile, false, 0700);
60
61	// std::string input_1 = R"({
62	// "network" : true,
63	// "script_file" : "script.py"
64	// })",
65	// input_2 = R"(n = 3
66	// for i in range(3):
67	// print("HELLO!!!"))";
68	// NOs::WriteToFile(DasbootFile, input_1);
69	// NOs::WriteToFile(ScriptFile, input_2);
70
71	// NMessages::TBuildOptions ExpectedBuildOptions;
72	// string ExpectedString;
73	// nlohmann::json resultJson;
74	// resultJson["network"] = true;
75	// resultJson["script_code"] = input_2;
76	// ExpectedBuildOptions.set_name("Container_name");
77	// ExpectedBuildOptions.set_dasboot_file(resultJson.dump());
78	// ExpectedBuildOptions.SerializeToString(&ExpectedString);
79
80	// NCli::TMainSettings settings;
81	// settings.BuildOptions.Name = "Container_name";
82	// settings.BuildOptions.PathToDasbootFile = "DasbootFile";
83	// string command = "build";
84	// NCli::TSender Sender("ipc:///tmp/testsocket");
85	// Sender.SendMainSettings(settings, command);
86	// string ServerMessage = server.GetMessage();
87	// server.SendMessage();
88
89	// NOs::RemoveFile(DasbootFile);
90	// NOs::RemoveFile(ScriptFile);
91
92	// ASSERT_EQ(ServerMessage, ExpectedString);
93	// }
94
95	// TEST(ControllerUt, CommandStart) {
96	// NMessages::TStartOptions ExpectedStartOptions;
97	// string ExpectedString;
98	// ExpectedStartOptions.SerializeToString(&ExpectedString);
99
100	// NCli::TMainSettings settings;
101	// string command = "start";
102	// NCli::TSender Sender("ipc:///tmp/testsocket");
103	// Sender.SendMainSettings(settings, command);
104	// string ServerMessage = server.GetMessage();
105	// server.SendMessage();
106
107	// ASSERT_EQ(ServerMessage, ExpectedString);
108	// }
109
110	// TEST(ControllerUt, CommandStop) {
111	// NMessages::TStopOptions ExpectedStopOptions;
112	// string ExpectedString;
113	// ExpectedStopOptions.set_name("Container_name");
114	// ExpectedStopOptions.SerializeToString(&ExpectedString);
115
116	// NCli::TMainSettings settings;
117	// settings.StopOptions.Name = "Container_name";
118	// string command = "stop";
119	// NCli::TSender Sender("ipc:///tmp/testsocket");
120	// Sender.SendMainSettings(settings, command);
121	// string ServerMessage = server.GetMessage();
122	// server.SendMessage();
123
124	// ASSERT_EQ(ServerMessage, ExpectedString);
125	// }
126
127	// TEST(ControllerUt, CommandPs) {
128	// NMessages::TPsOptions ExpectedPsOptions;
129	// string ExpectedString;
130	// ExpectedPsOptions.set_show_all(true);
131	// ExpectedPsOptions.SerializeToString(&ExpectedString);
132
133	// NCli::TMainSettings settings;
134	// settings.PsOptions.ShowAll = true;
135	// string command = "ps";
136	// NCli::TSender Sender("ipc:///tmp/testsocket");
137	// Sender.SendMainSettings(settings, command);
138	// string ServerMessage = server.GetMessage();
139	// server.SendMessage();
140
141	// ASSERT_EQ(ServerMessage, ExpectedString);
142	// }
143
144	// TEST(ControllerUt, CommandRm) {
145	// NMessages::TRmOptions ExpectedRmOptions;
146	// string ExpectedString;
147	// ExpectedRmOptions.set_id("Container_id");
148	// ExpectedRmOptions.SerializeToString(&ExpectedString);
149
150	// NCli::TMainSettings settings;
151	// settings.RmOptions.Id = "Container_id";
152	// string command = "rm";
153	// NCli::TSender Sender("ipc:///tmp/testsocket");
154	// Sender.SendMainSettings(settings, command);
155	// string ServerMessage = server.GetMessage();
156	// server.SendMessage();
157
158	// ASSERT_EQ(ServerMessage, ExpectedString);
159	// }
160
161	// TEST(ControllerUt, CommandExec) {
162	// std::string ExecFile = "ExecFile", CopyFile = "file.txt", ScriptFile = "script.py";
163	// NOs::CreateFile(ExecFile, false, 0700);
164	// NOs::CreateFile(CopyFile, false, 0700);
165	// NOs::CreateFile(ScriptFile, false, 0700);
166
167	// std::string input_1 = R"({
168	// "network" : true,
169	// "copy_file" : "file.txt",
170	// "script_file" : "script.py"
171	// })",
172	// input_2 = R"(HELLO WORLD)",
173	// input_3 = R"(print("HELLO!!!"))";
174	// NOs::WriteToFile(ExecFile, input_1);
175	// NOs::WriteToFile(CopyFile, input_2);
176	// NOs::WriteToFile(ScriptFile, input_3);
177
178	// NMessages::TExecOptions ExpectedExecOptions;
179	// nlohmann::json resultJson;
180	// string ExpectedString;
181	// std::vector<string> CodeFile, CodeFileNames;
182	// CodeFile.push_back(input_2);
183	// CodeFileNames.push_back(CopyFile);
184	// resultJson["network"] = true;
185	// resultJson["copy_file"] = CodeFile;
186	// resultJson["copy_file_names"] = CodeFileNames;
187	// resultJson["script_code"] = input_3;
188	// ExpectedExecOptions.set_name("Container_name");
189	// ExpectedExecOptions.set_id("Container_id");
190	// ExpectedExecOptions.set_detach(true);
191	// ExpectedExecOptions.set_exec_file(resultJson.dump());
192	// ExpectedExecOptions.SerializeToString(&ExpectedString);
193
194	// NCli::TMainSettings settings;
195	// settings.ExecOptions.Name = "Container_name";
196	// settings.ExecOptions.Id = "Container_id";
197	// settings.ExecOptions.Detach = true;
198	// settings.ExecOptions.ExecFile = ExecFile;
199	// string command = "exec";
200	// NCli::TSender Sender("ipc:///tmp/testsocket");
201	// Sender.SendMainSettings(settings, command);
202	// string ServerMessage = server.GetMessage();
203	// server.SendMessage();
204
205	// NOs::RemoveFile(ExecFile);
206	// NOs::RemoveFile(CopyFile);
207	// NOs::RemoveFile(ScriptFile);
208
209	// ASSERT_EQ(ServerMessage, ExpectedString);
210	// }
211
212
213	int main(int argc, char** argv) {	39✔
214	::testing::InitGoogleTest(&argc, argv);	39✔
215	auto result = RUN_ALL_TESTS();	39✔
216	return result;	39✔
217	}	39✔

KittensBasket / dasboot / 15243739334

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous