← Back to branch summary

~townsend/ubuntu-app-launch/remove-xmir-helpers

« back to all changes in this revision

Viewing changes to tests/systemd-mock.h

  • Committer: Chris Townsend
  • Date: 2017-03-24 13:06:32 UTC
  • mfrom: (269.1.38 ubuntu-app-launch)
  • Revision ID: christopher.townsend@canonical.com-20170324130632-n52ashmczuy0vy4y
Merge lp:ubuntu-app-launch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/systemd-mock.h
134
134
            &error);
135
135
        throwError(error);
136
136
 
137
 
        dbus_test_dbus_mock_object_add_method(mock, managerobj, "StartTransientUnit",
138
 
                                              G_VARIANT_TYPE("(ssa(sv)a(sa(sv)))"),
139
 
                                              G_VARIANT_TYPE_OBJECT_PATH, /* ret type */
140
 
                                              "ret = '/'", &error);
 
137
        dbus_test_dbus_mock_object_add_method(
 
138
            mock, managerobj, "StartTransientUnit", G_VARIANT_TYPE("(ssa(sv)a(sa(sv)))"),
 
139
            G_VARIANT_TYPE_OBJECT_PATH, /* ret type */
 
140
            std::accumulate(instances.begin(), instances.end(), std::string{"ret = '/'\n"},
 
141
                            [](const std::string accum, const Instance& inst) {
 
142
                                std::string retval = accum;
 
143
 
 
144
                                retval += "if args[0] == '" + instanceName(inst) + "':\n";
 
145
                                retval += "\traise dbus.exceptions.DBusException('Already running app" +
 
146
                                          instanceName(inst) + "', name='org.freedesktop.systemd1.UnitExists')\n";
 
147
 
 
148
                                return retval;
 
149
                            })
 
150
                .c_str(),
 
151
            &error);
141
152
        throwError(error);
142
153
 
143
154
        dbus_test_dbus_mock_object_add_method(mock, managerobj, "ResetFailedUnit", G_VARIANT_TYPE_STRING,
163
174
 
164
175
            g_mkdir_with_parents(dir, 0777);
165
176
 
166
 
            g_file_set_contents(tasks, std::accumulate(instance.pids.begin(), instance.pids.end(), std::string{},
167
 
                                                       [](const std::string& accum, pid_t pid) {
168
 
                                                           if (accum.empty())
169
 
                                                           {
170
 
                                                               return std::to_string(pid);
171
 
                                                           }
172
 
                                                           else
173
 
                                                           {
174
 
                                                               return accum + "\n" + std::to_string(pid);
175
 
                                                           }
176
 
                                                       })
177
 
                                           .c_str(),
 
177
            g_file_set_contents(tasks,
 
178
                                std::accumulate(instance.pids.begin(), instance.pids.end(), std::string{},
 
179
                                                [](const std::string& accum, pid_t pid) {
 
180
                                                    if (accum.empty())
 
181
                                                    {
 
182
                                                        return std::to_string(pid);
 
183
                                                    }
 
184
                                                    else
 
185
                                                    {
 
186
                                                        return accum + "\n" + std::to_string(pid);
 
187
                                                    }
 
188
                                                })
 
189
                                    .c_str(),
178
190
                                -1, &error);
179
191
            throwError(error);
180
192
 
225
237
 
226
238
    static std::string instanceName(const Instance& inst)
227
239
    {
228
 
        return std::string{"ubuntu-app-launch-"} + inst.job + "-" + inst.appid + "-" + inst.instanceid + ".service";
 
240
        return std::string{"ubuntu-app-launch--"} + inst.job + "--" + inst.appid + "--" + inst.instanceid + ".service";
229
241
    }
230
242
 
231
243
    operator std::shared_ptr<DbusTestTask>()
240
252
        return DBUS_TEST_TASK(mock);
241
253
    }
242
254
 
 
255
    operator DbusTestProcess*()
 
256
    {
 
257
        return DBUS_TEST_PROCESS(mock);
 
258
    }
 
259
 
243
260
    operator DbusTestDbusMock*()
244
261
    {
245
262
        return mock;
527
544
        }
528
545
    }
529
546
 
530
 
    void managerEmitFailed(const Instance& inst)
 
547
    void managerEmitFailed(const Instance& inst, const std::string& reason = "fail")
531
548
    {
532
549
        auto instobj =
533
550
            std::find_if(insts.begin(), insts.end(), [inst](const std::pair<Instance, DbusTestDbusMockObject*>& item) {
541
558
        }
542
559
 
543
560
        GError* error = nullptr;
544
 
        dbus_test_dbus_mock_object_update_property(mock, instobj->second, "Result", g_variant_new_string("fail"),
545
 
                                                   &error);
 
561
        dbus_test_dbus_mock_object_update_property(mock, instobj->second, "Result",
 
562
                                                   g_variant_new_string(reason.c_str()), &error);
546
563
 
547
564
        if (error != nullptr)
548
565
        {
551
568
            throw std::runtime_error{"Mock disfunctional"};
552
569
        }
553
570
    }
 
571
 
 
572
    std::function<DbusTestTaskState()> stateFunc()
 
573
    {
 
574
        return [this] { return dbus_test_task_get_state(DBUS_TEST_TASK(mock)); };
 
575
    }
554
576
};