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