← Back to branch summary

~ubuntu-branches/ubuntu/trusty/schroot/trusty

« back to all changes in this revision

Viewing changes to test/sbuild-chroot-lvm-snapshot.cc

  • Committer: Bazaar Package Importer
  • Author(s): Roger Leigh
  • Date: 2009-11-07 10:46:54 UTC
  • mfrom: (1.1.20 upstream) (2.1.6 experimental)
  • Revision ID: james.westby@ubuntu.com-20091107104654-kk1fp1icv8dzfyfi
http://bugs.debian.org/554907
* New upstream development release.
* schroot:
  - Return success when ending a session and the operation
    succeeded (Closes: #554907).

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/sbuild-chroot-lvm-snapshot.cc
19
19
#include <config.h>
20
20
 
21
21
#include <sbuild/sbuild-chroot-lvm-snapshot.h>
 
22
#include <sbuild/sbuild-chroot-facet-mountable.h>
 
23
#include <sbuild/sbuild-i18n.h>
22
24
#include <sbuild/sbuild-util.h>
23
25
 
24
26
#include "test-helpers.h"
31
33
 
32
34
using namespace CppUnit;
33
35
 
 
36
using sbuild::_;
 
37
 
34
38
class chroot_lvm_snapshot : public sbuild::chroot_lvm_snapshot
35
39
{
36
40
public:
49
53
  CPPUNIT_TEST(test_snapshot_options);
50
54
  CPPUNIT_TEST(test_chroot_type);
51
55
  CPPUNIT_TEST(test_setup_env);
 
56
  CPPUNIT_TEST(test_setup_env_session);
 
57
  CPPUNIT_TEST(test_setup_env_source);
 
58
  CPPUNIT_TEST(test_setup_keyfile);
 
59
  CPPUNIT_TEST(test_setup_keyfile_session);
 
60
  CPPUNIT_TEST(test_setup_keyfile_source);
52
61
  CPPUNIT_TEST(test_session_flags);
53
62
  CPPUNIT_TEST(test_print_details);
54
63
  CPPUNIT_TEST(test_print_config);
 
64
  CPPUNIT_TEST(test_run_setup_scripts);
55
65
  CPPUNIT_TEST_SUITE_END();
56
66
 
57
67
public:
62
72
  void setUp()
63
73
  {
64
74
    test_chroot_base<chroot_lvm_snapshot>::setUp();
65
 
    sbuild::chroot_lvm_snapshot *c = dynamic_cast<sbuild::chroot_lvm_snapshot *>(chroot.get());
66
 
    c->set_device("/dev/testdev");
67
 
    c->set_mount_options("-t jfs -o quota,rw");
68
 
    c->set_snapshot_device("/dev/snaptestdev");
 
75
    CPPUNIT_ASSERT(session);
 
76
    CPPUNIT_ASSERT(source);
 
77
    CPPUNIT_ASSERT(!chroot_union);
 
78
    CPPUNIT_ASSERT(!session_union);
 
79
    CPPUNIT_ASSERT(!source_union);
 
80
  }
 
81
 
 
82
  virtual void setup_chroot_props (sbuild::chroot::ptr& chroot)
 
83
  {
 
84
    test_chroot_base<chroot_lvm_snapshot>::setup_chroot_props(chroot);
 
85
 
 
86
    std::tr1::shared_ptr<sbuild::chroot_lvm_snapshot> c = std::tr1::dynamic_pointer_cast<sbuild::chroot_lvm_snapshot>(chroot);
 
87
 
 
88
    c->set_device("/dev/volgroup/testdev");
69
89
    c->set_snapshot_options("--size 1G");
 
90
 
 
91
    sbuild::chroot_facet_mountable::ptr pmnt(chroot->get_facet<sbuild::chroot_facet_mountable>());
 
92
    CPPUNIT_ASSERT(pmnt);
 
93
 
 
94
    pmnt->set_mount_options("-t jfs -o quota,rw");
 
95
    pmnt->set_location("/squeeze");
 
96
    //c->set_snapshot_device("/dev/volgroup/snaptestdev");
70
97
  }
71
98
 
72
99
  void
73
100
  test_snapshot_device()
74
101
  {
75
 
    sbuild::chroot_lvm_snapshot *c = dynamic_cast<sbuild::chroot_lvm_snapshot *>(chroot.get());
 
102
    std::tr1::shared_ptr<sbuild::chroot_lvm_snapshot> c = std::tr1::dynamic_pointer_cast<sbuild::chroot_lvm_snapshot>(chroot);
76
103
    CPPUNIT_ASSERT(c);
77
 
    c->set_snapshot_device("/dev/some/snapshot/device");
78
 
    CPPUNIT_ASSERT(c->get_snapshot_device() == "/dev/some/snapshot/device");
79
 
    CPPUNIT_ASSERT(chroot->get_mount_device() ==
80
 
                   "/dev/some/snapshot/device");
 
104
    c->set_snapshot_device("/dev/volgroup/some/snapshot/device");
 
105
    CPPUNIT_ASSERT(c->get_snapshot_device() == "/dev/volgroup/some/snapshot/device");
81
106
  }
82
107
 
83
108
  void
84
109
  test_snapshot_options()
85
110
  {
86
 
    sbuild::chroot_lvm_snapshot *c = dynamic_cast<sbuild::chroot_lvm_snapshot *>(chroot.get());
 
111
    std::tr1::shared_ptr<sbuild::chroot_lvm_snapshot> c = std::tr1::dynamic_pointer_cast<sbuild::chroot_lvm_snapshot>(chroot);
87
112
    CPPUNIT_ASSERT(c);
88
113
    c->set_snapshot_options("-o opt1,opt2");
89
114
    CPPUNIT_ASSERT(c->get_snapshot_options() == "-o opt1,opt2");
94
119
    CPPUNIT_ASSERT(chroot->get_chroot_type() == "lvm-snapshot");
95
120
  }
96
121
 
97
 
  void test_setup_env()
 
122
  void setup_env_gen(sbuild::environment &expected)
98
123
  {
99
 
    sbuild::chroot_lvm_snapshot *c = dynamic_cast<sbuild::chroot_lvm_snapshot *>(chroot.get());
100
 
    CPPUNIT_ASSERT(c);
101
 
 
102
 
    sbuild::environment expected;
103
 
    expected.add("CHROOT_TYPE",           "lvm-snapshot");
104
 
    expected.add("CHROOT_NAME",           "test-name");
105
 
    expected.add("CHROOT_DESCRIPTION",    "test-description");
 
124
    setup_env_chroot(expected);
 
125
    expected.add("CHROOT_LOCATION",       "/squeeze");
106
126
    expected.add("CHROOT_MOUNT_LOCATION", "/mnt/mount-location");
107
 
    expected.add("CHROOT_PATH",           "/mnt/mount-location");
108
 
    expected.add("CHROOT_MOUNT_DEVICE",   "/dev/snaptestdev");
109
 
    expected.add("CHROOT_DEVICE",         "/dev/testdev");
 
127
    expected.add("CHROOT_PATH",           "/mnt/mount-location/squeeze");
 
128
    expected.add("CHROOT_DEVICE",         "/dev/volgroup/testdev");
110
129
    expected.add("CHROOT_MOUNT_OPTIONS",  "-t jfs -o quota,rw");
111
 
    expected.add("CHROOT_LVM_SNAPSHOT_NAME", sbuild::basename(c->get_snapshot_device()));
112
 
    expected.add("CHROOT_LVM_SNAPSHOT_DEVICE", "/dev/snaptestdev");
113
 
    expected.add("CHROOT_LVM_SNAPSHOT_OPTIONS", "--size 1G");
114
 
    expected.add("CHROOT_SCRIPT_CONFIG",  sbuild::normalname(std::string(PACKAGE_SYSCONF_DIR) + "/script-defaults"));
115
 
    expected.add("CHROOT_SESSION_CLONE", "true");
116
 
    expected.add("CHROOT_SESSION_CREATE", "true");
117
 
    expected.add("CHROOT_SESSION_PURGE", "false");
118
 
 
119
 
    test_chroot_base<chroot_lvm_snapshot>::test_setup_env(expected);
 
130
  }
 
131
 
 
132
  void test_setup_env()
 
133
  {
 
134
    sbuild::environment expected;
 
135
    setup_env_gen(expected);
 
136
    expected.add("CHROOT_TYPE",           "lvm-snapshot");
 
137
    expected.add("CHROOT_LVM_SNAPSHOT_OPTIONS", "--size 1G");
 
138
    expected.add("CHROOT_SESSION_CLONE",  "true");
 
139
    expected.add("CHROOT_SESSION_CREATE", "true");
 
140
    expected.add("CHROOT_SESSION_PURGE",  "false");
 
141
 
 
142
    test_chroot_base<chroot_lvm_snapshot>::test_setup_env(chroot, expected);
 
143
  }
 
144
 
 
145
  void test_setup_env_session()
 
146
  {
 
147
    std::tr1::shared_ptr<sbuild::chroot_lvm_snapshot> c = std::tr1::dynamic_pointer_cast<sbuild::chroot_lvm_snapshot>(chroot);
 
148
 
 
149
    sbuild::environment expected;
 
150
    setup_env_gen(expected);
 
151
    expected.add("CHROOT_TYPE",           "lvm-snapshot");
 
152
    expected.add("CHROOT_NAME",           "test-session-name");
 
153
    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(session chroot)"));
 
154
    expected.add("CHROOT_MOUNT_DEVICE",   "/dev/volgroup/test-session-name");
 
155
    expected.add("CHROOT_LVM_SNAPSHOT_NAME",    "test-session-name");
 
156
    expected.add("CHROOT_LVM_SNAPSHOT_DEVICE",  "/dev/volgroup/test-session-name");
 
157
    expected.add("CHROOT_LVM_SNAPSHOT_OPTIONS", "--size 1G");
 
158
    expected.add("CHROOT_SESSION_CLONE",  "false");
 
159
    expected.add("CHROOT_SESSION_CREATE", "false");
 
160
    expected.add("CHROOT_SESSION_PURGE",  "true");
 
161
 
 
162
    test_chroot_base<chroot_lvm_snapshot>::test_setup_env(session, expected);
 
163
  }
 
164
 
 
165
  void test_setup_env_source()
 
166
  {
 
167
    sbuild::environment expected;
 
168
    setup_env_gen(expected);
 
169
    expected.add("CHROOT_TYPE",           "block-device");
 
170
    expected.add("CHROOT_NAME",           "test-name-source");
 
171
    expected.add("CHROOT_DESCRIPTION",     chroot->get_description() + ' ' + _("(source chroot)"));
 
172
    expected.add("CHROOT_MOUNT_DEVICE",   "/dev/volgroup/testdev");
 
173
    expected.add("CHROOT_SESSION_CLONE",  "false");
 
174
    expected.add("CHROOT_SESSION_CREATE", "true");
 
175
    expected.add("CHROOT_SESSION_PURGE",  "false");
 
176
    expected.add("CHROOT_UNION_TYPE",     "none");
 
177
 
 
178
    test_chroot_base<chroot_lvm_snapshot>::test_setup_env(source, expected);
 
179
  }
 
180
 
 
181
  void setup_keyfile_lvm(sbuild::keyfile &expected, std::string group)
 
182
  {
 
183
    expected.set_value(group, "device", "/dev/volgroup/testdev");
 
184
    expected.set_value(group, "location", "/squeeze");
 
185
    expected.set_value(group, "mount-options", "-t jfs -o quota,rw");
 
186
  }
 
187
 
 
188
  void test_setup_keyfile()
 
189
  {
 
190
    sbuild::keyfile expected;
 
191
    std::string group = chroot->get_name();
 
192
    setup_keyfile_chroot(expected, group);
 
193
    setup_keyfile_source(expected, group);
 
194
    setup_keyfile_lvm(expected, group);
 
195
    expected.set_value(group, "type", "lvm-snapshot");
 
196
    expected.set_value(group, "lvm-snapshot-options", "--size 1G");
 
197
 
 
198
    test_chroot_base<chroot_lvm_snapshot>::test_setup_keyfile
 
199
      (chroot,expected, chroot->get_name());
 
200
  }
 
201
 
 
202
  void test_setup_keyfile_session()
 
203
  {
 
204
    sbuild::keyfile expected;
 
205
    const std::string group(session->get_name());
 
206
    setup_keyfile_session(expected, group);
 
207
    setup_keyfile_lvm(expected, group);
 
208
    expected.set_value(group, "type", "lvm-snapshot");
 
209
    expected.set_value(group, "name", "test-session-name");
 
210
    expected.set_value(group, "description", chroot->get_description() + ' ' + _("(session chroot)"));
 
211
    expected.set_value(group, "aliases", "");
 
212
    expected.set_value(group, "lvm-snapshot-device", "/dev/volgroup/test-session-name");
 
213
    expected.set_value(group, "mount-device", "/dev/volgroup/test-session-name");
 
214
    expected.set_value(group, "mount-location", "/mnt/mount-location");
 
215
    expected.set_value(group, "mount-device", "/dev/volgroup/test-session-name");
 
216
 
 
217
    test_chroot_base<chroot_lvm_snapshot>::test_setup_keyfile
 
218
      (session, expected, group);
 
219
  }
 
220
 
 
221
  void test_setup_keyfile_source()
 
222
  {
 
223
    sbuild::keyfile expected;
 
224
    const std::string group(source->get_name());
 
225
    setup_keyfile_chroot(expected, group);
 
226
    setup_keyfile_lvm(expected, group);
 
227
    expected.set_value(group, "type", "block-device");
 
228
    expected.set_value(group, "description", chroot->get_description() + ' ' + _("(source chroot)"));
 
229
    expected.set_value(group, "aliases", "test-alias-1-source,test-alias-2-source");
 
230
    expected.set_value(group, "union-type", "none");
 
231
    setup_keyfile_source_clone(expected, group);
 
232
 
 
233
    test_chroot_base<chroot_lvm_snapshot>::test_setup_keyfile
 
234
      (source, expected, group);
120
235
  }
121
236
 
122
237
  void test_session_flags()
124
239
    CPPUNIT_ASSERT(chroot->get_session_flags() ==
125
240
                   (sbuild::chroot::SESSION_CREATE |
126
241
                    sbuild::chroot::SESSION_CLONE));
 
242
 
 
243
    CPPUNIT_ASSERT(session->get_session_flags() ==
 
244
                   (sbuild::chroot::SESSION_PURGE));
 
245
 
 
246
    /// @todo: Should return NOFLAGS?  This depends upon if source
 
247
    /// chroots need transforming into sessions as well (which should
 
248
    /// probably happen and be tested for independently).
 
249
    CPPUNIT_ASSERT(source->get_session_flags() ==
 
250
                   (sbuild::chroot::SESSION_CREATE));
127
251
  }
128
252
 
129
253
  void test_print_details()
143
267
    // TODO: Compare output.
144
268
    CPPUNIT_ASSERT(!os.str().empty());
145
269
  }
 
270
 
 
271
  void test_run_setup_scripts()
 
272
  {
 
273
    CPPUNIT_ASSERT(chroot->get_run_setup_scripts());
 
274
  }
 
275
 
146
276
};
147
277
 
148
278
CPPUNIT_TEST_SUITE_REGISTRATION(test_chroot_lvm_snapshot);