1
=== modified file 'libubuntu-app-launch/app-store-legacy.cpp'
2
--- libubuntu-app-launch/app-store-legacy.cpp	2017-04-04 06:03:50 +0000
3
+++ libubuntu-app-launch/app-store-legacy.cpp	2017-04-04 06:03:50 +0000
4
@@ -19,6 +19,7 @@
5
19
19
6
20
#include "app-store-legacy.h"
20
#include "app-store-legacy.h"
7
21
#include "application-impl-legacy.h"
21
#include "application-impl-legacy.h"
8
22
#include "registry-impl.h"
9
22
#include "string-util.h"
23
#include "string-util.h"
10
23
24
11
24
#include <regex>
25
#include <regex>
12
@@ -192,6 +193,177 @@
13
192
    return std::make_shared<app_impls::Legacy>(appid.appname, getReg());
193
    return std::make_shared<app_impls::Legacy>(appid.appname, getReg());
14
193
}
194
}
15
194
195
16
196
/** Turns a directory changed event from a file monitor into an
17
197
 *  internal signal. Makes sure we can deal with it first, and
18
198
 *  then propegates up the stack. */
19
199
void Legacy::directoryChanged(GFile* file, GFileMonitorEvent type)
20
200
{
21
201
    g_debug("Getting event for '%s'", unique_gchar(g_file_get_path(file)).get());
22
202
23
203
    auto filetype = g_file_query_file_type(file, G_FILE_QUERY_INFO_NONE, nullptr);
24
204
    if (filetype != G_FILE_TYPE_REGULAR && filetype != G_FILE_TYPE_UNKNOWN)
25
205
    {
26
206
        g_debug("\tNot a regular file");
27
207
        return;
28
208
    }
29
209
30
210
    auto cdesktopname = unique_gchar(g_file_get_basename(file));
31
211
    if (!cdesktopname)
32
212
    {
33
213
        g_debug("\tNo basename");
34
214
        return;
35
215
    }
36
216
    std::string desktopname{cdesktopname.get()};
37
217
38
218
    std::string appname;
39
219
    std::smatch match;
40
220
    if (std::regex_match(desktopname, match, desktop_remover))
41
221
    {
42
222
        appname = match[1].str();
43
223
    }
44
224
    else
45
225
    {
46
226
        return;
47
227
    }
48
228
49
229
    auto reg = getReg();
50
230
51
231
    switch (type)
52
232
    {
53
233
        case G_FILE_MONITOR_EVENT_CREATED:
54
234
        {
55
235
            auto app = std::make_shared<app_impls::Legacy>(AppID::AppName::from_raw(appname), reg);
56
236
57
237
            appAdded_(app);
58
238
            break;
59
239
        }
60
240
        case G_FILE_MONITOR_EVENT_CHANGED:
61
241
        {
62
242
            auto app = std::make_shared<app_impls::Legacy>(AppID::AppName::from_raw(appname), reg);
63
243
64
244
            infoChanged_(app);
65
245
            break;
66
246
        }
67
247
        case G_FILE_MONITOR_EVENT_DELETED:
68
248
        {
69
249
            AppID appid{AppID::Package::from_raw({}), AppID::AppName::from_raw(appname), AppID::Version::from_raw({})};
70
250
            if (verifyAppname(appid.package, appid.appname))
71
251
            {
72
252
                /* Check to see if we've got a shadow situation and we
73
253
                 * can still build this app */
74
254
                auto app = std::make_shared<app_impls::Legacy>(AppID::AppName::from_raw(appname), reg);
75
255
                infoChanged_(app);
76
256
            }
77
257
            else
78
258
            {
79
259
                appRemoved_(appid);
80
260
            }
81
261
            break;
82
262
        }
83
263
        default:
84
264
            break;
85
265
    };
86
266
}
87
267
88
268
/** Function that setups file monitors on all of the system application
89
269
 *  directories and the user application directory. Any time an application
90
270
 *  is added or removed or changed we send the appropriate signal up the
91
271
 *  stack. */
92
272
void Legacy::setupMonitors()
93
273
{
94
274
    std::call_once(monitorsSetup_, [this]() {
95
275
        auto reg = getReg();
96
276
        monitors_ =
97
277
            reg->thread.executeOnThread<std::set<std::unique_ptr<GFileMonitor, unity::util::GObjectDeleter>>>([this]() {
98
278
                std::set<std::unique_ptr<GFileMonitor, unity::util::GObjectDeleter>> monitors;
99
279
100
280
                auto monitorDir = [this](const gchar* dirname) {
101
281
                    auto appdir = unique_gchar(g_build_filename(dirname, "applications", nullptr));
102
282
                    auto gfile = unity::util::unique_gobject(g_file_new_for_path(appdir.get()));
103
283
104
284
                    if (!g_file_query_exists(gfile.get(), nullptr))
105
285
                    {
106
286
                        throw std::runtime_error{std::string{"Directory '"} + appdir.get() + "' doesn't exist"};
107
287
                    }
108
288
109
289
                    if (g_file_query_file_type(gfile.get(), G_FILE_QUERY_INFO_NONE, nullptr) != G_FILE_TYPE_DIRECTORY)
110
290
                    {
111
291
                        throw std::runtime_error{std::string{"'"} + appdir.get() + "' is not a directory"};
112
292
                    }
113
293
114
294
                    GError* error = nullptr;
115
295
                    auto monitor = unity::util::unique_gobject(
116
296
                        g_file_monitor_directory(gfile.get(), G_FILE_MONITOR_NONE, nullptr, &error));
117
297
118
298
                    if (error != nullptr)
119
299
                    {
120
300
                        std::string message = std::string{"Unable to create file monitor: "} + error->message;
121
301
                        g_error_free(error);
122
302
                        throw std::runtime_error{message};
123
303
                    }
124
304
125
305
                    g_signal_connect(
126
306
                        monitor.get(), "changed",
127
307
                        G_CALLBACK(+[](GFileMonitor*, GFile* file, GFile*, GFileMonitorEvent type, gpointer user_data) {
128
308
                            auto pthis = static_cast<Legacy*>(user_data);
129
309
                            pthis->directoryChanged(file, type);
130
310
                        }),
131
311
                        this);
132
312
133
313
                    return monitor;
134
314
                };
135
315
136
316
                auto dirs = g_get_system_data_dirs();
137
317
                for (int i = 0; dirs != nullptr && dirs[i] != nullptr; i++)
138
318
                {
139
319
                    try
140
320
                    {
141
321
                        monitors.insert(monitorDir(dirs[i]));
142
322
                    }
143
323
                    catch (std::runtime_error& e)
144
324
                    {
145
325
                        g_debug("Unable to create directory monitor for system dir '%s': %s", dirs[i], e.what());
146
326
                    }
147
327
                }
148
328
149
329
                try
150
330
                {
151
331
                    monitors.insert(monitorDir(g_get_user_data_dir()));
152
332
                }
153
333
                catch (std::runtime_error& e)
154
334
                {
155
335
                    g_debug("Unable to create directory monitor for user data dir: %s", e.what());
156
336
                }
157
337
158
338
                return monitors;
159
339
            });
160
340
    });
161
341
}
162
342
163
343
/** Return the signal object, but make sure we have the
164
344
 *  monitors setup first */
165
345
core::Signal<const std::shared_ptr<Application>&>& Legacy::infoChanged()
166
346
{
167
347
    setupMonitors();
168
348
    return infoChanged_;
169
349
}
170
350
171
351
/** Return the signal object, but make sure we have the
172
352
 *  monitors setup first */
173
353
core::Signal<const std::shared_ptr<Application>&>& Legacy::appAdded()
174
354
{
175
355
    setupMonitors();
176
356
    return appAdded_;
177
357
}
178
358
179
359
/** Return the signal object, but make sure we have the
180
360
 *  monitors setup first */
181
361
core::Signal<const AppID&>& Legacy::appRemoved()
182
362
{
183
363
    setupMonitors();
184
364
    return appRemoved_;
185
365
}
186
366
187
195
}  // namespace app_store
367
}  // namespace app_store
188
196
}  // namespace app_launch
368
}  // namespace app_launch
189
197
}  // namespace ubuntu
369
}  // namespace ubuntu
190
198
370
191
=== modified file 'libubuntu-app-launch/app-store-legacy.h'
192
--- libubuntu-app-launch/app-store-legacy.h	2017-04-04 06:03:50 +0000
193
+++ libubuntu-app-launch/app-store-legacy.h	2017-04-04 06:03:50 +0000
194
@@ -21,6 +21,8 @@
195
21
21
196
22
#include "app-store-base.h"
22
#include "app-store-base.h"
197
23
23
198
24
#include <unity/util/GObjectMemory.h>
199
25
200
24
namespace ubuntu
26
namespace ubuntu
201
25
{
27
{
202
26
namespace app_launch
28
namespace app_launch
203
@@ -46,6 +48,18 @@
204
46
48
205
47
    /* Application Creation */
49
    /* Application Creation */
206
48
    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid) override;
50
    virtual std::shared_ptr<app_impls::Base> create(const AppID& appid) override;
207
51
208
52
    /* Info watching */
209
53
    virtual core::Signal<const std::shared_ptr<Application>&>& infoChanged() override;
210
54
    virtual core::Signal<const std::shared_ptr<Application>&>& appAdded() override;
211
55
    virtual core::Signal<const AppID&>& appRemoved() override;
212
56
213
57
private:
214
58
    std::set<std::unique_ptr<GFileMonitor, unity::util::GObjectDeleter>> monitors_;
215
59
    std::once_flag monitorsSetup_;
216
60
217
61
    void directoryChanged(GFile* file, GFileMonitorEvent type);
218
62
    void setupMonitors();
219
49
};
63
};
220
50
64
221
51
}  // namespace app_store
65
}  // namespace app_store
222
52
66
223
=== modified file 'libubuntu-app-launch/info-watcher.h'
224
--- libubuntu-app-launch/info-watcher.h	2017-04-04 06:03:50 +0000
225
+++ libubuntu-app-launch/info-watcher.h	2017-04-04 06:03:50 +0000
226
@@ -43,9 +43,23 @@
227
43
        return infoChanged_;
43
        return infoChanged_;
228
44
    }
44
    }
229
45
45
230
46
    virtual core::Signal<const std::shared_ptr<Application>&>& appAdded()
231
47
    {
232
48
        return appAdded_;
233
49
    }
234
50
235
51
    virtual core::Signal<const AppID&>& appRemoved()
236
52
    {
237
53
        return appRemoved_;
238
54
    }
239
55
240
46
protected:
56
protected:
241
47
    /** Signal for info changed on an application */
57
    /** Signal for info changed on an application */
242
48
    core::Signal<const std::shared_ptr<Application>&> infoChanged_;
58
    core::Signal<const std::shared_ptr<Application>&> infoChanged_;
243
59
    /** Signal for applications added */
244
60
    core::Signal<const std::shared_ptr<Application>&> appAdded_;
245
61
    /** Signal for applications removed */
246
62
    core::Signal<const AppID&> appRemoved_;
247
49
63
248
50
    /** Accessor function to the registry that ensures we can still
64
    /** Accessor function to the registry that ensures we can still
249
51
        get it, which we always should be able to, but in case. */
65
        get it, which we always should be able to, but in case. */
250
52
66
251
=== modified file 'libubuntu-app-launch/registry-impl.cpp'
252
--- libubuntu-app-launch/registry-impl.cpp	2017-04-04 06:03:50 +0000
253
+++ libubuntu-app-launch/registry-impl.cpp	2017-04-04 06:03:50 +0000
254
@@ -171,25 +171,51 @@
255
171
    return watchingAppStarting_;
171
    return watchingAppStarting_;
256
172
}
172
}
257
173
173
258
174
/** Sets up the signals down to the info watchers and we aggregate
259
175
    them up to users of UAL. We connect to all their signals and
260
176
    pass them up. */
261
177
void Registry::Impl::infoWatchersSetup()
262
178
{
263
179
    std::call_once(flag_infoWatchersSetup, [this] {
264
180
        g_debug("Info watchers signals setup");
265
181
266
182
        /* Grab all the app stores and the ZG info watcher */
267
183
        std::list<std::shared_ptr<info_watcher::Base>> watchers{_appStores.begin(), _appStores.end()};
268
184
        watchers.push_back(getZgWatcher());
269
185
270
186
        /* Connect each of their signals to us, and track that connection */
271
187
        for (const auto& watcher : watchers)
272
188
        {
273
189
            infoWatchers_.emplace_back(std::make_pair(
274
190
                watcher,
275
191
                infoWatcherConnections{
276
192
                    watcher->infoChanged().connect(
277
193
                        [this](const std::shared_ptr<Application>& app) { sig_appInfoUpdated(app); }),
278
194
                    watcher->appAdded().connect([this](const std::shared_ptr<Application>& app) { sig_appAdded(app); }),
279
195
                    watcher->appRemoved().connect([this](const AppID& appid) { sig_appRemoved(appid); }),
280
196
                }));
281
197
        }
282
198
    });
283
199
}
284
200
285
174
core::Signal<const std::shared_ptr<Application>&>& Registry::Impl::appInfoUpdated()
201
core::Signal<const std::shared_ptr<Application>&>& Registry::Impl::appInfoUpdated()
286
175
{
202
{
301
176
    std::call_once(flag_appInfoUpdated, [this] {
203
    infoWatchersSetup();
288
177
        g_debug("App Info Updated Signal Initialized");
289
178
290
179
        std::list<std::shared_ptr<info_watcher::Base>> apps{_appStores.begin(), _appStores.end()};
291
180
        apps.push_back(getZgWatcher());
292
181
293
182
        for (const auto& app : apps)
294
183
        {
295
184
            infoWatchers_.emplace_back(
296
185
                std::make_pair(app, app->infoChanged().connect([this](const std::shared_ptr<Application>& app) {
297
186
                    sig_appInfoUpdated(app);
298
187
                })));
299
188
        }
300
189
    });
302
190
    return sig_appInfoUpdated;
204
    return sig_appInfoUpdated;
303
191
}
205
}
304
192
206
305
207
core::Signal<const std::shared_ptr<Application>&>& Registry::Impl::appAdded()
306
208
{
307
209
    infoWatchersSetup();
308
210
    return sig_appAdded;
309
211
}
310
212
311
213
core::Signal<const AppID&>& Registry::Impl::appRemoved()
312
214
{
313
215
    infoWatchersSetup();
314
216
    return sig_appRemoved;
315
217
}
316
218
317
193
std::shared_ptr<Application> Registry::Impl::createApp(const AppID& appid)
219
std::shared_ptr<Application> Registry::Impl::createApp(const AppID& appid)
318
194
{
220
{
319
195
    for (const auto& appStore : appStores())
221
    for (const auto& appStore : appStores())
320
196
222
321
=== modified file 'libubuntu-app-launch/registry-impl.h'
322
--- libubuntu-app-launch/registry-impl.h	2017-04-04 06:03:50 +0000
323
+++ libubuntu-app-launch/registry-impl.h	2017-04-04 06:03:50 +0000
324
@@ -98,6 +98,8 @@
325
98
    }
98
    }
326
99
99
327
100
    core::Signal<const std::shared_ptr<Application>&>& appInfoUpdated();
100
    core::Signal<const std::shared_ptr<Application>&>& appInfoUpdated();
328
101
    core::Signal<const std::shared_ptr<Application>&>& appAdded();
329
102
    core::Signal<const AppID&>& appRemoved();
330
101
103
331
102
    const std::list<std::shared_ptr<app_store::Base>>& appStores()
104
    const std::list<std::shared_ptr<app_store::Base>>& appStores()
332
103
    {
105
    {
333
@@ -156,10 +158,23 @@
334
156
158
335
157
    /** Signal for application info changing */
159
    /** Signal for application info changing */
336
158
    core::Signal<const std::shared_ptr<Application>&> sig_appInfoUpdated;
160
    core::Signal<const std::shared_ptr<Application>&> sig_appInfoUpdated;
337
161
    /** Signal for applications added */
338
162
    core::Signal<const std::shared_ptr<Application>&> sig_appAdded;
339
163
    /** Signal for applications removed */
340
164
    core::Signal<const AppID&> sig_appRemoved;
341
165
342
166
    void infoWatchersSetup(const std::shared_ptr<Registry>& reg);
343
159
    /** Flag to see if we've initialized the info watcher list */
167
    /** Flag to see if we've initialized the info watcher list */
345
160
    std::once_flag flag_appInfoUpdated;
168
    std::once_flag flag_infoWatchersSetup;
346
169
    struct infoWatcherConnections
347
170
    {
348
171
        core::ScopedConnection infoUpdated;
349
172
        core::ScopedConnection appAdded;
350
173
        core::ScopedConnection appRemoved;
351
174
    };
352
161
    /** List of info watchers along with a signal handle to our connection to their update signal */
175
    /** List of info watchers along with a signal handle to our connection to their update signal */
354
162
    std::list<std::pair<std::shared_ptr<info_watcher::Base>, core::ScopedConnection>> infoWatchers_;
176
    std::list<std::pair<std::shared_ptr<info_watcher::Base>, infoWatcherConnections>> infoWatchers_;
355
177
    void infoWatchersSetup();
356
163
178
357
164
    /** ZG Info Watcher */
179
    /** ZG Info Watcher */
358
165
    std::shared_ptr<info_watcher::Zeitgeist> zgWatcher_;
180
    std::shared_ptr<info_watcher::Zeitgeist> zgWatcher_;
359
166
181
360
=== modified file 'libubuntu-app-launch/registry.cpp'
361
--- libubuntu-app-launch/registry.cpp	2017-04-04 06:03:50 +0000
362
+++ libubuntu-app-launch/registry.cpp	2017-04-04 06:03:50 +0000
363
@@ -154,5 +154,15 @@
364
154
    return reg->impl->appInfoUpdated();
154
    return reg->impl->appInfoUpdated();
365
155
}
155
}
366
156
156
367
157
core::Signal<const std::shared_ptr<Application>&>& Registry::appAdded(const std::shared_ptr<Registry>& reg)
368
158
{
369
159
    return reg->impl->appAdded();
370
160
}
371
161
372
162
core::Signal<const AppID&>& Registry::appRemoved(const std::shared_ptr<Registry>& reg)
373
163
{
374
164
    return reg->impl->appRemoved();
375
165
}
376
166
377
157
}  // namespace app_launch
167
}  // namespace app_launch
378
158
}  // namespace ubuntu
168
}  // namespace ubuntu
379
159
169
380
=== modified file 'libubuntu-app-launch/registry.h'
381
--- libubuntu-app-launch/registry.h	2017-04-04 06:03:50 +0000
382
+++ libubuntu-app-launch/registry.h	2017-04-04 06:03:50 +0000
383
@@ -137,6 +137,25 @@
384
137
    static core::Signal<const std::shared_ptr<Application>&>& appInfoUpdated(
137
    static core::Signal<const std::shared_ptr<Application>&>& appInfoUpdated(
385
138
        const std::shared_ptr<Registry>& reg = getDefault());
138
        const std::shared_ptr<Registry>& reg = getDefault());
386
139
139
387
140
    /** Get the signal object that is signaled when there is a new application
388
141
        that has been added to the system.
389
142
390
143
        \note This signal handler is activated on the UAL thread
391
144
392
145
        \param reg Registry to get the handler from
393
146
    */
394
147
    static core::Signal<const std::shared_ptr<Application>&>& appAdded(
395
148
        const std::shared_ptr<Registry>& reg = getDefault());
396
149
397
150
    /** Get the signal object that is signaled when an application is
398
151
        removed from the system.
399
152
400
153
        \note This signal handler is activated on the UAL thread
401
154
402
155
        \param reg Registry to get the handler from
403
156
    */
404
157
    static core::Signal<const AppID&>& appRemoved(const std::shared_ptr<Registry>& reg = getDefault());
405
158
406
140
    /** The Application Manager, almost always if you're not Unity8, don't
159
    /** The Application Manager, almost always if you're not Unity8, don't
407
141
        use this API. Testing is a special case. Subclass this interface and
160
        use this API. Testing is a special case. Subclass this interface and
408
142
        implement these functions.
161
        implement these functions.
409
143
162
410
=== modified file 'tests/CMakeLists.txt'
411
--- tests/CMakeLists.txt	2017-03-14 16:46:00 +0000
412
+++ tests/CMakeLists.txt	2017-04-04 06:03:50 +0000
413
@@ -50,6 +50,15 @@
414
50
add_test (NAME libual-test COMMAND libual-test)
50
add_test (NAME libual-test COMMAND libual-test)
415
51
add_test (NAME libual-cpp-test COMMAND libual-cpp-test)
51
add_test (NAME libual-cpp-test COMMAND libual-cpp-test)
416
52
52
417
53
# App Store Legacy
418
54
419
55
add_executable (app-store-legacy
420
56
	app-store-legacy.cpp)
421
57
target_link_libraries (app-store-legacy ${GMOCK_LIBRARIES} ${GTEST_MAIN_LIBRARIES} launcher-static ${DBUSTEST_LIBRARIES})
422
58
423
59
add_test(NAME app-store-legacy COMMAND "${CMAKE_CURRENT_BINARY_DIR}/app-store-legacy" --gtest_list_tests "|" grep "\"^  \"" "|" xargs -n 1 printf "\"--gtest_filter=*.%s\\n\"" "|" xargs -n 1 "${CMAKE_CURRENT_BINARY_DIR}/app-store-legacy")
424
60
425
61
426
53
# Jobs Base Test
62
# Jobs Base Test
427
54
63
428
55
add_executable (jobs-base-test
64
add_executable (jobs-base-test
429
@@ -129,6 +138,7 @@
430
129
add_custom_target(format-tests
138
add_custom_target(format-tests
431
130
	COMMAND clang-format -i -style=file
139
	COMMAND clang-format -i -style=file
432
131
	application-info-desktop.cpp
140
	application-info-desktop.cpp
433
141
	app-store-legacy.cpp
434
132
	libual-cpp-test.cc
142
	libual-cpp-test.cc
435
133
	libual-test.cc
143
	libual-test.cc
436
134
	list-apps.cpp
144
	list-apps.cpp
437
135
145
438
=== added file 'tests/app-store-legacy.cpp'
439
--- tests/app-store-legacy.cpp	1970-01-01 00:00:00 +0000
440
+++ tests/app-store-legacy.cpp	2017-04-04 06:03:50 +0000
441
@@ -0,0 +1,155 @@
442
1
/*
443
2
 * Copyright © 2017 Canonical Ltd.
444
3
 *
445
4
 * This program is free software: you can redistribute it and/or modify it
446
5
 * under the terms of the GNU General Public License version 3, as published
447
6
 * by the Free Software Foundation.
448
7
 *
449
8
 * This program is distributed in the hope that it will be useful, but
450
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
451
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
452
11
 * PURPOSE.  See the GNU General Public License for more details.
453
12
 *
454
13
 * You should have received a copy of the GNU General Public License along
455
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
456
15
 *
457
16
 * Authors:
458
17
 *     Ted Gould <ted.gould@canonical.com>
459
18
 */
460
19
461
20
#include "app-store-legacy.h"
462
21
463
22
#include "eventually-fixture.h"
464
23
#include "registry-mock.h"
465
24
#include "test-directory.h"
466
25
#include <gmock/gmock.h>
467
26
#include <gtest/gtest.h>
468
27
#include <libdbustest/dbus-test.h>
469
28
#include <unity/util/GObjectMemory.h>
470
29
#include <unity/util/GlibMemory.h>
471
30
472
31
class AppStoreLegacy : public EventuallyFixture
473
32
{
474
33
protected:
475
34
    std::unique_ptr<DbusTestService, unity::util::GObjectDeleter> service;
476
35
    std::shared_ptr<RegistryMock> registry;
477
36
478
37
    virtual void SetUp()
479
38
    {
480
39
        setenv("XDG_DATA_DIRS", CMAKE_SOURCE_DIR, 1);
481
40
482
41
        service = unity::util::unique_gobject(dbus_test_service_new(nullptr));
483
42
        dbus_test_service_start_tasks(service.get());
484
43
        registry = std::make_shared<RegistryMock>(std::list<std::shared_ptr<ubuntu::app_launch::app_store::Base>>{},
485
44
                                                  std::shared_ptr<ubuntu::app_launch::jobs::manager::Base>{});
486
45
    }
487
46
};
488
47
489
48
TEST_F(AppStoreLegacy, Init)
490
49
{
491
50
    auto store = std::make_shared<ubuntu::app_launch::app_store::Legacy>(registry->impl);
492
51
    store.reset();
493
52
}
494
53
495
54
TEST_F(AppStoreLegacy, FindApp)
496
55
{
497
56
    TestDirectory testdir;
498
57
    testdir.addApp("testapp",
499
58
                   {{G_KEY_FILE_DESKTOP_GROUP,
500
59
                     {
501
60
                         {G_KEY_FILE_DESKTOP_KEY_NAME, "Test App"},
502
61
                         {G_KEY_FILE_DESKTOP_KEY_TYPE, "Application"},
503
62
                         {G_KEY_FILE_DESKTOP_KEY_ICON, "foo.png"},
504
63
                         {G_KEY_FILE_DESKTOP_KEY_EXEC, "foo"},
505
64
                     }}});
506
65
507
66
    auto store = std::make_shared<ubuntu::app_launch::app_store::Legacy>(registry->impl);
508
67
509
68
    EXPECT_TRUE(store->verifyAppname(ubuntu::app_launch::AppID::Package::from_raw({}),
510
69
                                     ubuntu::app_launch::AppID::AppName::from_raw("testapp")));
511
70
}
512
71
513
72
TEST_F(AppStoreLegacy, RemoveApp)
514
73
{
515
74
    TestDirectory testdir;
516
75
    testdir.addApp("testapp",
517
76
                   {{G_KEY_FILE_DESKTOP_GROUP,
518
77
                     {
519
78
                         {G_KEY_FILE_DESKTOP_KEY_NAME, "Test App"},
520
79
                         {G_KEY_FILE_DESKTOP_KEY_TYPE, "Application"},
521
80
                         {G_KEY_FILE_DESKTOP_KEY_ICON, "foo.png"},
522
81
                         {G_KEY_FILE_DESKTOP_KEY_EXEC, "foo"},
523
82
                     }}});
524
83
525
84
    auto store = std::make_shared<ubuntu::app_launch::app_store::Legacy>(registry->impl);
526
85
527
86
    std::promise<std::string> removedAppId;
528
87
    store->appRemoved().connect([&](const ubuntu::app_launch::AppID &appid) { removedAppId.set_value(appid); });
529
88
530
89
    testdir.removeApp("testapp");
531
90
532
91
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{"testapp"}, removedAppId.get_future());
533
92
}
534
93
535
94
TEST_F(AppStoreLegacy, AddedApp)
536
95
{
537
96
    TestDirectory testdir;
538
97
    auto store = std::make_shared<ubuntu::app_launch::app_store::Legacy>(registry->impl);
539
98
540
99
    std::promise<std::string> addedAppId;
541
100
    store->appAdded().connect(
542
101
        [&](const std::shared_ptr<ubuntu::app_launch::Application> &app) { addedAppId.set_value(app->appId()); });
543
102
544
103
    testdir.addApp("testapp",
545
104
                   {{G_KEY_FILE_DESKTOP_GROUP,
546
105
                     {
547
106
                         {G_KEY_FILE_DESKTOP_KEY_NAME, "Test App"},
548
107
                         {G_KEY_FILE_DESKTOP_KEY_TYPE, "Application"},
549
108
                         {G_KEY_FILE_DESKTOP_KEY_ICON, "foo.png"},
550
109
                         {G_KEY_FILE_DESKTOP_KEY_EXEC, "foo"},
551
110
                     }}});
552
111
553
112
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{"testapp"}, addedAppId.get_future());
554
113
}
555
114
556
115
TEST_F(AppStoreLegacy, ShadowDelete)
557
116
{
558
117
    TestDirectory testdir;
559
118
    testdir.addApp("testapp",
560
119
                   {{G_KEY_FILE_DESKTOP_GROUP,
561
120
                     {
562
121
                         {G_KEY_FILE_DESKTOP_KEY_NAME, "Test App"},
563
122
                         {G_KEY_FILE_DESKTOP_KEY_TYPE, "Application"},
564
123
                         {G_KEY_FILE_DESKTOP_KEY_ICON, "foo.png"},
565
124
                         {G_KEY_FILE_DESKTOP_KEY_EXEC, "foo"},
566
125
                     }}});
567
126
568
127
    TestDirectory testdir2;
569
128
    testdir2.addApp("testapp",
570
129
                    {{G_KEY_FILE_DESKTOP_GROUP,
571
130
                      {
572
131
                          {G_KEY_FILE_DESKTOP_KEY_NAME, "Test App"},
573
132
                          {G_KEY_FILE_DESKTOP_KEY_TYPE, "Application"},
574
133
                          {G_KEY_FILE_DESKTOP_KEY_ICON, "foo.png"},
575
134
                          {G_KEY_FILE_DESKTOP_KEY_EXEC, "foo"},
576
135
                      }}});
577
136
578
137
    auto store = std::make_shared<ubuntu::app_launch::app_store::Legacy>(registry->impl);
579
138
580
139
    std::promise<std::string> updatedAppId;
581
140
    store->infoChanged().connect(
582
141
        [&](const std::shared_ptr<ubuntu::app_launch::Application> &app) { updatedAppId.set_value(app->appId()); });
583
142
584
143
    std::promise<std::string> deleteAppId;
585
144
    store->appRemoved().connect([&](const ubuntu::app_launch::AppID &appid) { deleteAppId.set_value(appid); });
586
145
    std::shared_future<std::string> deleteFuture = deleteAppId.get_future();
587
146
588
147
    testdir.removeApp("testapp");
589
148
590
149
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{"testapp"}, updatedAppId.get_future());
591
150
    EXPECT_NE(std::future_status::ready, deleteFuture.wait_for(std::chrono::seconds{0}));
592
151
593
152
    testdir2.removeApp("testapp");
594
153
595
154
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{"testapp"}, deleteFuture);
596
155
}
597
0
156
598
=== modified file 'tests/eventually-fixture.h'
599
--- tests/eventually-fixture.h	2017-01-18 20:43:25 +0000
600
+++ tests/eventually-fixture.h	2017-04-04 06:03:50 +0000
601
@@ -118,6 +118,37 @@
602
118
        return eventuallyLoop(func);                                                                             \
118
        return eventuallyLoop(func);                                                                             \
603
119
    }
119
    }
604
120
120
605
121
#define _EVENTUALLY_FUTURE_HELPER(oper)                                                                            \
606
122
    template <typename comptype>                                                                                   \
607
123
    testing::AssertionResult eventuallyFutureHelper##oper(const char *desca, const char *descb, comptype expected, \
608
124
                                                          std::future<comptype> future)                            \
609
125
    {                                                                                                              \
610
126
        std::function<testing::AssertionResult(void)> func = [&]() {                                               \
611
127
            auto status = future.wait_for(std::chrono::seconds{0});                                                \
612
128
            if (status != std::future_status::ready)                                                               \
613
129
            {                                                                                                      \
614
130
                return testing::AssertionFailure();                                                                \
615
131
            }                                                                                                      \
616
132
            return testing::internal::CmpHelper##oper(desca, descb, expected, future.get());                       \
617
133
        };                                                                                                         \
618
134
        return eventuallyLoop(func);                                                                               \
619
135
    }                                                                                                              \
620
136
                                                                                                                   \
621
137
    template <typename comptype>                                                                                   \
622
138
    testing::AssertionResult eventuallyFutureHelper##oper(const char *desca, const char *descb, comptype expected, \
623
139
                                                          std::shared_future<comptype> future)                     \
624
140
    {                                                                                                              \
625
141
        std::function<testing::AssertionResult(void)> func = [&]() {                                               \
626
142
            auto status = future.wait_for(std::chrono::seconds{0});                                                \
627
143
            if (status != std::future_status::ready)                                                               \
628
144
            {                                                                                                      \
629
145
                return testing::AssertionFailure();                                                                \
630
146
            }                                                                                                      \
631
147
            return testing::internal::CmpHelper##oper(desca, descb, expected, future.get());                       \
632
148
        };                                                                                                         \
633
149
        return eventuallyLoop(func);                                                                               \
634
150
    }
635
151
636
121
    _EVENTUALLY_HELPER(EQ);
152
    _EVENTUALLY_HELPER(EQ);
637
122
    _EVENTUALLY_HELPER(NE);
153
    _EVENTUALLY_HELPER(NE);
638
123
    _EVENTUALLY_HELPER(LT);
154
    _EVENTUALLY_HELPER(LT);
639
@@ -132,8 +163,16 @@
640
132
    _EVENTUALLY_FUNC_HELPER(STREQ);
163
    _EVENTUALLY_FUNC_HELPER(STREQ);
641
133
    _EVENTUALLY_FUNC_HELPER(STRNE);
164
    _EVENTUALLY_FUNC_HELPER(STRNE);
642
134
165
643
166
    _EVENTUALLY_FUTURE_HELPER(EQ);
644
167
    _EVENTUALLY_FUTURE_HELPER(NE);
645
168
    _EVENTUALLY_FUTURE_HELPER(LT);
646
169
    _EVENTUALLY_FUTURE_HELPER(GT);
647
170
    _EVENTUALLY_FUTURE_HELPER(STREQ);
648
171
    _EVENTUALLY_FUTURE_HELPER(STRNE);
649
172
650
135
#undef _EVENTUALLY_HELPER
173
#undef _EVENTUALLY_HELPER
651
136
#undef _EVENTUALLY_FUNC_HELPER
174
#undef _EVENTUALLY_FUNC_HELPER
652
175
#undef _EVENTUALLY_FUTURE_HELPER
653
137
};
176
};
654
138
177
655
139
/* Helpers */
178
/* Helpers */
656
@@ -209,3 +248,40 @@
657
209
248
658
210
#define ASSERT_EVENTUALLY_FUNC_STRNE(expected, actual) \
249
#define ASSERT_EVENTUALLY_FUNC_STRNE(expected, actual) \
659
211
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFuncHelperSTRNE, expected, actual)
250
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFuncHelperSTRNE, expected, actual)
660
251
661
252
/* Future Helpers */
662
253
#define EXPECT_EVENTUALLY_FUTURE_EQ(expected, actual) \
663
254
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperEQ, expected, actual)
664
255
665
256
#define EXPECT_EVENTUALLY_FUTURE_NE(expected, actual) \
666
257
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperNE, expected, actual)
667
258
668
259
#define EXPECT_EVENTUALLY_FUTURE_LT(expected, actual) \
669
260
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperLT, expected, actual)
670
261
671
262
#define EXPECT_EVENTUALLY_FUTURE_GT(expected, actual) \
672
263
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperGT, expected, actual)
673
264
674
265
#define EXPECT_EVENTUALLY_FUTURE_STREQ(expected, actual) \
675
266
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperSTREQ, expected, actual)
676
267
677
268
#define EXPECT_EVENTUALLY_FUTURE_STRNE(expected, actual) \
678
269
    EXPECT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperSTRNE, expected, actual)
679
270
680
271
#define ASSERT_EVENTUALLY_FUTURE_EQ(expected, actual) \
681
272
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperEQ, expected, actual)
682
273
683
274
#define ASSERT_EVENTUALLY_FUTURE_NE(expected, actual) \
684
275
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperNE, expected, actual)
685
276
686
277
#define ASSERT_EVENTUALLY_FUTURE_LT(expected, actual) \
687
278
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperLT, expected, actual)
688
279
689
280
#define ASSERT_EVENTUALLY_FUTURE_GT(expected, actual) \
690
281
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperGT, expected, actual)
691
282
692
283
#define ASSERT_EVENTUALLY_FUTURE_STREQ(expected, actual) \
693
284
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperSTREQ, expected, actual)
694
285
695
286
#define ASSERT_EVENTUALLY_FUTURE_STRNE(expected, actual) \
696
287
    ASSERT_PRED_FORMAT2(EventuallyFixture::eventuallyFutureHelperSTRNE, expected, actual)
697
212
288
698
=== modified file 'tests/jobs-systemd.cpp'
699
--- tests/jobs-systemd.cpp	2017-04-04 06:03:50 +0000
700
+++ tests/jobs-systemd.cpp	2017-04-04 06:03:50 +0000
701
@@ -326,7 +326,7 @@
702
326
                                {defaultJobName(), std::string{multipleAppID()}, "1234", 1, {}}),
326
                                {defaultJobName(), std::string{multipleAppID()}, "1234", 1, {}}),
703
327
                            "/foo");
327
                            "/foo");
704
328
328
706
329
    EXPECT_EQ(multipleAppID(), newunit.get_future().get());
329
    EXPECT_EVENTUALLY_FUTURE_EQ(multipleAppID(), newunit.get_future());
707
330
}
330
}
708
331
331
709
332
TEST_F(JobsSystemd, SignalRemove)
332
TEST_F(JobsSystemd, SignalRemove)
710
@@ -362,7 +362,7 @@
711
362
                                    {defaultJobName(), std::string{multipleAppID()}, "1234567890", 1, {}}),
362
                                    {defaultJobName(), std::string{multipleAppID()}, "1234567890", 1, {}}),
712
363
                                "/foo");
363
                                "/foo");
713
364
364
715
365
    EXPECT_EQ(multipleAppID(), removeunit.get_future().get());
365
    EXPECT_EVENTUALLY_FUTURE_EQ(multipleAppID(), removeunit.get_future());
716
366
}
366
}
717
367
367
718
368
TEST_F(JobsSystemd, UnitFailure)
368
TEST_F(JobsSystemd, UnitFailure)
719
369
369
720
=== modified file 'tests/libual-cpp-test.cc'
721
--- tests/libual-cpp-test.cc	2017-04-04 06:03:50 +0000
722
+++ tests/libual-cpp-test.cc	2017-04-04 06:03:50 +0000
723
@@ -44,6 +44,7 @@
724
44
#include "snapd-mock.h"
44
#include "snapd-mock.h"
725
45
#include "spew-master.h"
45
#include "spew-master.h"
726
46
#include "systemd-mock.h"
46
#include "systemd-mock.h"
727
47
#include "test-directory.h"
728
47
#include "zg-mock.h"
48
#include "zg-mock.h"
729
48
49
730
49
#define LOCAL_SNAPD_TEST_SOCKET (SNAPD_TEST_SOCKET "-libual-cpp-test")
50
#define LOCAL_SNAPD_TEST_SOCKET (SNAPD_TEST_SOCKET "-libual-cpp-test")
731
@@ -1154,6 +1155,46 @@
732
1154
    g_spawn_command_line_sync("rm -rf " CMAKE_BINARY_DIR "/libual-proc", NULL, NULL, NULL, NULL);
1155
    g_spawn_command_line_sync("rm -rf " CMAKE_BINARY_DIR "/libual-proc", NULL, NULL, NULL, NULL);
733
1155
}
1156
}
734
1156
1157
735
1158
TEST_F(LibUAL, AppInfoSignals)
736
1159
{
737
1160
    /* Setup the stores mock */
738
1161
    auto mockstore = std::make_shared<MockStore>(registry->impl);
739
1162
    registry =
740
1163
        std::make_shared<RegistryMock>(std::list<std::shared_ptr<ubuntu::app_launch::app_store::Base>>{mockstore},
741
1164
                                       std::shared_ptr<ubuntu::app_launch::jobs::manager::Base>{});
742
1165
743
1166
    /* Build an app */
744
1167
    auto singleappid = ubuntu::app_launch::AppID::find(registry, "single");
745
1168
    auto myapp = std::make_shared<MockApp>(singleappid, registry->impl);
746
1169
747
1170
    /* Setup an app added signal handler */
748
1171
    std::promise<ubuntu::app_launch::AppID> addedAppId;
749
1172
    ubuntu::app_launch::Registry::appAdded(registry).connect(
750
1173
        [&](const std::shared_ptr<ubuntu::app_launch::Application>& app) { addedAppId.set_value(app->appId()); });
751
1174
752
1175
    mockstore->mock_signalAppAdded(myapp);
753
1176
754
1177
    EXPECT_EVENTUALLY_FUTURE_EQ(singleappid, addedAppId.get_future());
755
1178
756
1179
    /* Setup an info changed signal handler */
757
1180
    std::promise<ubuntu::app_launch::AppID> changedAppId;
758
1181
    ubuntu::app_launch::Registry::appInfoUpdated(registry).connect(
759
1182
        [&](const std::shared_ptr<ubuntu::app_launch::Application>& app) { changedAppId.set_value(app->appId()); });
760
1183
761
1184
    mockstore->mock_signalAppInfoChanged(myapp);
762
1185
763
1186
    EXPECT_EVENTUALLY_FUTURE_EQ(singleappid, changedAppId.get_future());
764
1187
765
1188
    /* Setup an app removed signal handler */
766
1189
    std::promise<ubuntu::app_launch::AppID> removedAppId;
767
1190
    ubuntu::app_launch::Registry::appRemoved(registry).connect(
768
1191
        [&](const ubuntu::app_launch::AppID& appid) { removedAppId.set_value(appid); });
769
1192
770
1193
    mockstore->mock_signalAppRemoved(singleappid);
771
1194
772
1195
    EXPECT_EVENTUALLY_FUTURE_EQ(singleappid, removedAppId.get_future());
773
1196
}
774
1197
775
1157
TEST_F(LibUAL, OOMSet)
1198
TEST_F(LibUAL, OOMSet)
776
1158
{
1199
{
777
1159
    g_setenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH", CMAKE_BINARY_DIR "/libual-proc", 1);
1200
    g_setenv("UBUNTU_APP_LAUNCH_OOM_PROC_PATH", CMAKE_BINARY_DIR "/libual-proc", 1);
778
@@ -1277,13 +1318,7 @@
779
1277
    });
1318
    });
780
1278
    t.detach();
1319
    t.detach();
781
1279
1320
789
1280
    auto outputfuture = outputpromise.get_future();
1321
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{filedata}, outputpromise.get_future());
783
1281
    while (outputfuture.wait_for(std::chrono::milliseconds{1}) != std::future_status::ready)
784
1282
    {
785
1283
        pause();
786
1284
    }
787
1285
788
1286
    ASSERT_STREQ(filedata, outputfuture.get().c_str());
790
1287
1322
791
1288
    return;
1323
    return;
792
1289
}
1324
}
793
@@ -1376,7 +1411,7 @@
794
1376
    std::vector<std::string> execList{"Foo", "Bar", "Really really really long value", "Another value"};
1411
    std::vector<std::string> execList{"Foo", "Bar", "Really really really long value", "Another value"};
795
1377
    ubuntu::app_launch::Helper::setExec(execList);
1412
    ubuntu::app_launch::Helper::setExec(execList);
796
1378
1413
798
1379
    EXPECT_EQ(execList, socketpromise.get_future().get());
1414
    EXPECT_EVENTUALLY_FUTURE_EQ(execList, socketpromise.get_future());
799
1380
}
1415
}
800
1381
1416
801
1382
TEST_F(LibUAL, AppInfo)
1417
TEST_F(LibUAL, AppInfo)
802
1383
1418
803
=== modified file 'tests/libual-test.cc'
804
--- tests/libual-test.cc	2017-03-20 15:21:13 +0000
805
+++ tests/libual-test.cc	2017-04-04 06:03:50 +0000
806
@@ -892,13 +892,7 @@
807
892
    });
892
    });
808
893
    t.detach();
893
    t.detach();
809
894
894
817
895
    auto outputfuture = outputpromise.get_future();
895
    EXPECT_EVENTUALLY_FUTURE_EQ(std::string{filedata}, outputpromise.get_future());
811
896
    while (outputfuture.wait_for(std::chrono::milliseconds{1}) != std::future_status::ready)
812
897
    {
813
898
        pause();
814
899
    }
815
900
816
901
    ASSERT_STREQ(filedata, outputfuture.get().c_str());
818
902
896
819
903
    return;
897
    return;
820
904
}
898
}
821
@@ -1002,7 +996,7 @@
822
1002
                                          .c_str(),
996
                                          .c_str(),
823
1003
                                      nullptr);
997
                                      nullptr);
824
1004
998
826
1005
    EXPECT_EQ(execList, socketpromise.get_future().get());
999
    EXPECT_EVENTUALLY_FUTURE_EQ(execList, socketpromise.get_future());
827
1006
}
1000
}
828
1007
1001
829
1008
TEST_F(LibUAL, AppInfo)
1002
TEST_F(LibUAL, AppInfo)
830
1009
1003
831
=== modified file 'tests/registry-mock.h'
832
--- tests/registry-mock.h	2017-04-04 06:03:50 +0000
833
+++ tests/registry-mock.h	2017-04-04 06:03:50 +0000
834
@@ -54,6 +54,19 @@
835
54
54
836
55
    /* Application Creation */
55
    /* Application Creation */
837
56
    MOCK_METHOD1(create, std::shared_ptr<ubuntu::app_launch::app_impls::Base>(const ubuntu::app_launch::AppID&));
56
    MOCK_METHOD1(create, std::shared_ptr<ubuntu::app_launch::app_impls::Base>(const ubuntu::app_launch::AppID&));
838
57
839
58
    void mock_signalAppAdded(const std::shared_ptr<ubuntu::app_launch::Application>& app)
840
59
    {
841
60
        appAdded_(app);
842
61
    }
843
62
    void mock_signalAppRemoved(const ubuntu::app_launch::AppID& appid)
844
63
    {
845
64
        appRemoved_(appid);
846
65
    }
847
66
    void mock_signalAppInfoChanged(const std::shared_ptr<ubuntu::app_launch::Application>& app)
848
67
    {
849
68
        infoChanged_(app);
850
69
    }
851
57
};
70
};
852
58
71
853
59
class MockApp : public ubuntu::app_launch::app_impls::Base
72
class MockApp : public ubuntu::app_launch::app_impls::Base
854
60
73
855
=== added file 'tests/test-directory.h'
856
--- tests/test-directory.h	1970-01-01 00:00:00 +0000
857
+++ tests/test-directory.h	2017-04-04 06:03:50 +0000
858
@@ -0,0 +1,94 @@
859
1
/*
860
2
 * Copyright © 2017 Canonical Ltd.
861
3
 *
862
4
 * This program is free software: you can redistribute it and/or modify it
863
5
 * under the terms of the GNU General Public License version 3, as published
864
6
 * by the Free Software Foundation.
865
7
 *
866
8
 * This program is distributed in the hope that it will be useful, but
867
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of
868
10
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
869
11
 * PURPOSE.  See the GNU General Public License for more details.
870
12
 *
871
13
 * You should have received a copy of the GNU General Public License along
872
14
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
873
15
 *
874
16
 * Authors:
875
17
 *     Ted Gould <ted.gould@canonical.com>
876
18
 */
877
19
878
20
#include <unity/util/GlibMemory.h>
879
21
#include <string>
880
22
881
23
class TestDirectory
882
24
{
883
25
    std::string dirname_;
884
26
    std::string appdir_;
885
27
886
28
public:
887
29
    TestDirectory()
888
30
    {
889
31
        GError *error{nullptr};
890
32
891
33
        auto dirname = ubuntu::app_launch::unique_gchar(g_dir_make_tmp("xdg-data-tmp-XXXXXX", &error));
892
34
        if (error != nullptr)
893
35
        {
894
36
            auto message = std::string{"Unable to create temporary directory: "} + error->message;
895
37
            g_error_free(error);
896
38
            throw std::runtime_error{message};
897
39
        }
898
40
        dirname_ = dirname.get();
899
41
        g_debug("Setting temp XDG_DATA directory: %s", dirname.get());
900
42
901
43
        appdir_ = ubuntu::app_launch::unique_gchar(g_build_filename(dirname.get(), "applications", nullptr)).get();
902
44
        g_mkdir_with_parents(appdir_.c_str(), 0700);
903
45
904
46
        auto datadirs =
905
47
            ubuntu::app_launch::unique_gchar(g_strdup_printf("%s:%s", dirname.get(), g_getenv("XDG_DATA_DIRS")));
906
48
        setenv("XDG_DATA_DIRS", datadirs.get(), 1);
907
49
    }
908
50
909
51
    ~TestDirectory()
910
52
    {
911
53
        auto command = ubuntu::app_launch::unique_gchar(g_strdup_printf("rm -rf %s", dirname_.c_str()));
912
54
        g_spawn_command_line_sync(command.get(), nullptr, nullptr, nullptr, nullptr);
913
55
        g_debug("Removing test directory: %s", dirname_.c_str());
914
56
    }
915
57
916
58
    void addApp(const std::string &appname,
917
59
                const std::list<std::pair<std::string, std::list<std::pair<std::string, std::string>>>> &keydata)
918
60
    {
919
61
        auto keyfile = unity::util::unique_glib(g_key_file_new());
920
62
921
63
        for (const auto &groupset : keydata)
922
64
        {
923
65
            auto groupname = groupset.first;
924
66
            for (const auto &dataset : groupset.second)
925
67
            {
926
68
                auto key = dataset.first;
927
69
                auto value = dataset.second;
928
70
929
71
                g_key_file_set_string(keyfile.get(), groupname.c_str(), key.c_str(), value.c_str());
930
72
            }
931
73
        }
932
74
933
75
        auto path = ubuntu::app_launch::unique_gchar(
934
76
            g_build_filename(appdir_.c_str(), (appname + ".desktop").c_str(), nullptr));
935
77
        GError *error{nullptr};
936
78
937
79
        g_key_file_save_to_file(keyfile.get(), path.get(), &error);
938
80
        if (error != nullptr)
939
81
        {
940
82
            auto message = std::string{"Unable to write desktop file for '"} + appname + "': " + error->message;
941
83
            g_error_free(error);
942
84
            throw std::runtime_error{message};
943
85
        }
944
86
    }
945
87
946
88
    void removeApp(const std::string &appname)
947
89
    {
948
90
        auto path = ubuntu::app_launch::unique_gchar(
949
91
            g_build_filename(appdir_.c_str(), (appname + ".desktop").c_str(), nullptr));
950
92
        unlink(path.get());
951
93
    }
952
94
};
953
0
95
954
=== modified file 'tools/ubuntu-app-watch.cpp'
955
--- tools/ubuntu-app-watch.cpp	2017-02-08 17:34:52 +0000
956
+++ tools/ubuntu-app-watch.cpp	2017-04-04 06:03:50 +0000
957
@@ -29,16 +29,16 @@
958
29
29
959
30
    registry.appStarted().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
30
    registry.appStarted().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
960
31
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance) {
31
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance) {
962
32
        std::cout << "Started: " << (std::string)app->appId() << std::endl;
32
        std::cout << "Started: " << std::string{app->appId()} << std::endl;
963
33
    });
33
    });
964
34
    registry.appStopped().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
34
    registry.appStopped().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
965
35
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance) {
35
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance) {
967
36
        std::cout << "Stopped: " << (std::string)app->appId() << std::endl;
36
        std::cout << "Stopped: " << std::string{app->appId()} << std::endl;
968
37
    });
37
    });
969
38
    registry.appPaused().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
38
    registry.appPaused().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
970
39
                                    const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
39
                                    const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
971
40
                                    const std::vector<pid_t>& pids) {
40
                                    const std::vector<pid_t>& pids) {
973
41
        std::cout << "Paused:  " << (std::string)app->appId() << " (";
41
        std::cout << "Paused:  " << std::string{app->appId()} << " (";
974
42
42
975
43
        for (auto pid : pids)
43
        for (auto pid : pids)
976
44
        {
44
        {
977
@@ -50,7 +50,7 @@
978
50
    registry.appResumed().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
50
    registry.appResumed().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
979
51
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
51
                                     const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
980
52
                                     const std::vector<pid_t>& pids) {
52
                                     const std::vector<pid_t>& pids) {
982
53
        std::cout << "Resumed: " << (std::string)app->appId() << " (";
53
        std::cout << "Resumed: " << std::string{app->appId()} << " (";
983
54
54
984
55
        for (auto pid : pids)
55
        for (auto pid : pids)
985
56
        {
56
        {
986
@@ -62,7 +62,7 @@
987
62
    registry.appFailed().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
62
    registry.appFailed().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app,
988
63
                                    const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
63
                                    const std::shared_ptr<ubuntu::app_launch::Application::Instance>& instance,
989
64
                                    ubuntu::app_launch::Registry::FailureType type) {
64
                                    ubuntu::app_launch::Registry::FailureType type) {
991
65
        std::cout << "Failed:  " << (std::string)app->appId();
65
        std::cout << "Failed:  " << std::string{app->appId()};
992
66
        switch (type)
66
        switch (type)
993
67
        {
67
        {
994
68
            case ubuntu::app_launch::Registry::FailureType::CRASH:
68
            case ubuntu::app_launch::Registry::FailureType::CRASH:
995
@@ -74,6 +74,14 @@
996
74
        }
74
        }
997
75
        std::cout << std::endl;
75
        std::cout << std::endl;
998
76
    });
76
    });
999
77
    registry.appAdded().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app) {
1000
78
        std::cout << "Added:   " << std::string{app->appId()} << std::endl;
1001
79
    });
1002
80
    registry.appRemoved().connect(
1003
81
        [](const ubuntu::app_launch::AppID& appid) { std::cout << "Removed: " << std::string{appid} << std::endl; });
1004
82
    registry.appInfoUpdated().connect([](const std::shared_ptr<ubuntu::app_launch::Application>& app) {
1005
83
        std::cout << "Updated: " << std::string{app->appId()} << std::endl;
1006
84
    });
1007
77
85
1008
78
    std::signal(SIGTERM, [](int signal) -> void { retval.set_value(EXIT_SUCCESS); });
86
    std::signal(SIGTERM, [](int signal) -> void { retval.set_value(EXIT_SUCCESS); });
1009
79
    return retval.get_future().get();
87
    return retval.get_future().get();
Reviewer	Review Type	Date Requested	Status
Pete Woods (community)			Approve on 2017-04-04
Marcus Tomlinson (community)		2017-03-29	Approve on 2017-04-04
unity-api-1-bot	continuous-integration		Needs Fixing on 2017-04-04
Review via email: mp+321241@code.launchpad.net