tests.ut.rules.dub source code

1 module tests.ut.rules.dub;
2 
3 
4 import reggae;
5 import unit_threaded;
6 
7 
8 @("dubTarget with lflags")
9 unittest {
10 
11     import reggae.rules.dub: dubTarget;
12     import std.typecons: Yes, No;
13 
14     DubInfo dubInfo;
15     dubInfo.packages = [DubPackage()];
16     dubInfo.packages[0].lflags = ["-L$FOO"];
17     Target[] objects;
18     const actual = dubTarget!()(TargetName("app"),
19                                 dubInfo,
20                                 "-g -debug",
21                                 [],
22                                 Yes.main,
23                                 No.allTogether,
24     );
25     const expected = Target("app",
26                             Command(CommandType.link,
27                                     assocList([assocEntry("flags",
28                                                           ["-L-L$FOO"])])),
29                             []);
30     actual.shouldEqual(expected);
31 }
32 
33 
34 
35 @("dubTarget with static library source with env var in path")
36 unittest {
37 
38     import reggae.rules.dub: dubTarget;
39     import reggae.config: setOptions;
40     import reggae.options: getOptions;
41     import std.typecons: Yes, No;
42     import std.algorithm: filter;
43     import std.array: split;
44 
45     setOptions(getOptions(["reggae", "/tmp/proj"]));
46 
47     DubInfo dubInfo;
48     dubInfo.packages = [DubPackage()];
49     dubInfo.packages[0].files = ["$LIB/liblua.a", "source/luad/foo.d"];
50     dubInfo.packages[0].importPaths = ["source"];
51     Target[] objects;
52     const actual = dubTarget!()(TargetName("app"),
53                                 dubInfo,
54                                 "-g -debug",
55                                 [],
56                                 Yes.main,
57                                 No.allTogether,
58     );
59 
60     string[] empty;
61 
62     auto compileTarget = Target("source/luad.o",
63                                 Command(CommandType.compile,
64                                         assocList(
65                                              [
66                                                  assocEntry("includes", ["-Isource", "-I/tmp/proj"]),
67                                                  assocEntry("flags", ["-g", "-debug"]),
68                                                  assocEntry("stringImports", empty),
69                                                  assocEntry("DEPFILE", ["source/luad.o.dep"])
70                                              ])),
71                                  [Target("source/luad/foo.d")],
72     );
73 
74     const expected = Target("app",
75                             Command(CommandType.link,
76                                     assocList([assocEntry("flags",
77                                                           empty)])),
78                             [compileTarget, Target("$LIB/liblua.a")]);
79 
80     actual.shouldEqual(expected);
81     Options options;
82     options.dCompiler = "dmd";
83     options.projectPath = "/proj";
84     actual.shellCommand(options).split(" ").filter!(a => a != "").
85         shouldEqual(["dmd", "-ofapp", "source/luad.o", "$LIB/liblua.a"]);
86 }
87 
88 //FIXME: includes should not have all of them
89 @("versions from main package apply to all packages")
90 unittest {
91 
92     import reggae.rules.dub: dubTarget;
93     import reggae.config: options, setOptions;
94     import std.typecons: Yes, No;
95 
96     auto oldOptions = options;
97     scope(exit) setOptions(oldOptions);
98     auto newOptions = oldOptions.dup;
99     newOptions.perModule = true;
100     newOptions.projectPath = "/leproj";
101     setOptions(newOptions);
102 
103     DubInfo dubInfo;
104     dubInfo.packages = [DubPackage("myapp", "/path/myapp"), DubPackage("dep", "/path/dep")];
105     dubInfo.packages[0].files = ["src/file1.d", "src/file2.d"];
106     dubInfo.packages[0].importPaths = ["/path/myapp/src"];
107     dubInfo.packages[0].versions = ["foo", "bar"];
108     dubInfo.packages[0].dependencies = ["dep"];
109     dubInfo.packages[1].files = ["source/dep1.d", "source/dep2.d"];
110     dubInfo.packages[1].importPaths = ["/path/dep/source"];
111     dubInfo.packages[1].versions = ["quux"];
112 
113     Target[] objects;
114     const actual = dubTarget!()(TargetName("app"),
115                                 dubInfo,
116                                 "-g",
117                                 [],
118                                 Yes.main,
119                                 No.allTogether,
120     );
121     string[] empty;
122     const expected =
123         Target("app",
124                Command(CommandType.link,
125                        assocList([assocEntry("flags",
126                                              empty)])),
127                [
128                    Target("path/myapp/src/file1.o",
129                           Command(CommandType.compile,
130                                   assocList([
131                                                 assocEntry("includes",
132                                                            ["-I/path/myapp/src", "-I/path/dep/source", "-I/leproj"]),
133                                                 assocEntry("flags", ["-version=foo", "-version=bar", "-version=quux", "-g"]),
134                                                 assocEntry("stringImports", empty),
135                                                 assocEntry("DEPFILE", ["path/myapp/src/file1.o.dep"])
136                                                       ])),
137                           [Target("/path/myapp/src/file1.d")]),
138 
139                    Target("path/myapp/src/file2.o",
140                           Command(CommandType.compile,
141                                   assocList([
142                                                 assocEntry("includes",
143                                                            ["-I/path/myapp/src", "-I/path/dep/source", "-I/leproj"]),
144                                                 assocEntry("flags", ["-version=foo", "-version=bar", "-version=quux", "-g"]),
145                                                 assocEntry("stringImports", empty),
146                                                              assocEntry("DEPFILE", ["path/myapp/src/file2.o.dep"])
147                                                 ])),
148                           [Target("/path/myapp/src/file2.d")]),
149 
150                    Target("path/dep/source/dep1.o",
151                           Command(CommandType.compile,
152                                   assocList([
153                                                 assocEntry("includes",
154                                                            ["-I/path/myapp/src", "-I/path/dep/source", "-I/leproj"]),
155                                                 assocEntry("flags", ["-version=foo", "-version=bar", "-version=quux", "-g"]),
156                                                 assocEntry("stringImports", empty),
157                                                 assocEntry("DEPFILE", ["path/dep/source/dep1.o.dep"])
158                                                 ])),
159                           [Target("/path/dep/source/dep1.d")]),
160 
161                    Target("path/dep/source/dep2.o",
162                           Command(CommandType.compile,
163                                   assocList([
164                                                 assocEntry("includes",
165                                                            ["-I/path/myapp/src", "-I/path/dep/source", "-I/leproj"]),
166                                                 assocEntry("flags", ["-version=foo", "-version=bar", "-version=quux", "-g"]),
167                                                 assocEntry("stringImports", empty),
168                                                 assocEntry("DEPFILE", ["path/dep/source/dep2.o.dep"])
169                                                 ])),
170                           [Target("/path/dep/source/dep2.d")]),
171 
172              ]
173         );
174     actual.shouldEqual(expected);
175 }
176 
177 
178 @("static library dubConfigurationTarget")
179 unittest {
180     auto oldOptions = options;
181     scope(exit) setOptions(oldOptions);
182 
183     auto newOptions = oldOptions.dup;
184     newOptions.perModule = false;
185     newOptions.projectPath = "/leproj";
186     setOptions(newOptions);
187 
188     auto dubInfo = DubInfo([DubPackage("myapp", "/path/myapp")]);
189     dubInfo.packages[0].files = ["src/file1.d", "src/file2.d"];
190     dubInfo.packages[0].targetType = TargetType.library;
191 
192     string[] empty;
193     const expected = Target("$builddir/libfoo.a",
194                             Command("ar rcs $out $in"),
195                             [Target("path/myapp/src.o",
196                                     Command(CommandType.compile,
197                                             assocList([
198                                                           assocEntry("includes", ["-I/leproj"]),
199                                                           assocEntry("flags", ["-g"]),
200                                                           assocEntry("stringImports", empty),
201                                                           assocEntry("DEPFILE", ["path/myapp/src.o.dep"]),
202                                                           ])),
203                                     [Target("/path/myapp/src/file1.d"), Target("/path/myapp/src/file2.d")])]);
204     dubTarget(TargetName("libfoo.a"), dubInfo, "-g").shouldEqual(expected);
205 }
206 
207 
208 @("object files as dub srcFiles")
209 unittest {
210     auto oldOptions = options;
211     scope(exit) setOptions(oldOptions);
212 
213     auto newOptions = oldOptions.dup;
214     newOptions.perModule = false;
215     newOptions.projectPath = "/leproj";
216     setOptions(newOptions);
217 
218     auto dubInfo = DubInfo([DubPackage("myapp", "/path/myapp")]);
219     dubInfo.packages[0].files = ["src/file1.d", "src/file2.d", "bin/dep.o"];
220 
221     string[] empty;
222     const expected = Target("libfoo.a",
223                             Command(CommandType.link, assocList([assocEntry("flags", empty)])),
224                             [
225                                 Target("path/myapp/src.o",
226                                        Command(CommandType.compile,
227                                                assocList([
228                                                              assocEntry("includes", ["-I/leproj"]),
229                                                              assocEntry("flags", ["-g"]),
230                                                              assocEntry("stringImports", empty),
231                                                              assocEntry("DEPFILE", ["path/myapp/src.o.dep"]),
232                                                          ])),
233                                        [Target("/path/myapp/src/file1.d"), Target("/path/myapp/src/file2.d")]),
234 
235                                 Target("/path/myapp/bin/dep.o"),
236                             ]);
237     dubTarget(TargetName("libfoo.a"), dubInfo, "-g").shouldEqual(expected);
238 }