11512106788

Committed 25 Oct 2024 04:51AM CUT coverage: 84.386%. Remained the same

Build # 11512106788

Build Type

push

github

Committed by

me-viper

Commit Message

ci: Add CI inputs

Run Details

1820 of 2364 branches covered (76.99%)

Branch coverage included in aggregate %.

3817 of 4316 relevant lines covered (88.44%)

1737.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

49.41

/src/Compilation.Abstractions/src/RegoCompilerExtensions.cs

﻿using JetBrains.Annotations;

namespace OpaDotNet.Compilation.Abstractions;

/// <summary>
/// Compilation extensions.
/// </summary>
[PublicAPI]
public static class RegoCompilerExtensions
{
    /// <summary>
    /// Compiles OPA bundle from bundle directory.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="bundlePath">Bundle directory or bundle archive path.</param>
    /// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
    /// <param name="capabilitiesFilePath">
    /// Capabilities file that defines the built-in functions and other language features that policies may depend on.
    /// </param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    [Obsolete("Use IRegoCompiler.CompileBundleAsync instead")]
    public static async Task<Stream> CompileBundle(
        this IRegoCompiler compiler,
        string bundlePath,
        IEnumerable<string>? entrypoints = null,
        string? capabilitiesFilePath = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrEmpty(bundlePath);

        var opts = new CompilationParameters
        {
            Entrypoints = entrypoints?.ToList(),
            CapabilitiesFilePath = capabilitiesFilePath,
            IsBundle = true,
        };

        return await compiler.CompileBundleAsync(bundlePath, opts, cancellationToken).ConfigureAwait(false);
    }

    /// <summary>
    /// Compiles OPA bundle from rego policy source file.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="sourceFilePath">Source file path.</param>
    /// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    [Obsolete("Use IRegoCompiler.CompileFileAsync instead")]
    public static Task<Stream> CompileFile(
        this IRegoCompiler compiler,
        string sourceFilePath,
        IEnumerable<string>? entrypoints = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrEmpty(sourceFilePath);

        var opts = new CompilationParameters { Entrypoints = entrypoints?.ToList() };
        return compiler.Compile(sourceFilePath, opts, cancellationToken);
    }

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="bundle">Rego bundle stream.</param>
    /// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
    /// <param name="capabilitiesJson">
    /// Capabilities json that defines the built-in functions and other language features that policies may depend on.
    /// </param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    [Obsolete("Use IRegoCompiler.CompileBundleAsync instead")]
    public static Task<Stream> CompileStream(
        this IRegoCompiler compiler,
        Stream bundle,
        IEnumerable<string>? entrypoints = null,
        Stream? capabilitiesJson = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(bundle);

        var capsMem = Memory<byte>.Empty;

        if (capabilitiesJson != null)
        {
            capsMem = new byte[(int)capabilitiesJson.Length];
            _ = capabilitiesJson.Read(capsMem.Span);
        }

        var opts = new CompilationParameters
        {
            Entrypoints = entrypoints?.ToList(),
            CapabilitiesBytes = capsMem,
            IsBundle = true,
        };

        return compiler.CompileBundleAsync(bundle, opts, cancellationToken);
    }

    /// <summary>
    /// Compiles OPA bundle from rego policy source code.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="source">Source file path.</param>
    /// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    [Obsolete("Use IRegoCompiler.CompileSourceAsync instead")]
    public static Task<Stream> CompileSource(
        this IRegoCompiler compiler,
        string source,
        IEnumerable<string>? entrypoints = null,
        CancellationToken cancellationToken = default)
    {
        var opts = new CompilationParameters
        {
            Entrypoints = entrypoints?.ToList(),
            IsBundle = true,
        };

        return compiler.CompileSourceAsync(source, opts, cancellationToken);
    }

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="sourceFilePath">Source file path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileFileAsync(
        this IRegoCompiler compiler,
        string sourceFilePath,
        CompilationParameters parameters) => CompileFileAsync(compiler, sourceFilePath, parameters, CancellationToken.None);

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="sourceFilePath">Source file path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static async Task<Stream> CompileFileAsync(
        this IRegoCompiler compiler,
        string sourceFilePath,
        CompilationParameters parameters,
        CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrEmpty(sourceFilePath);
        ArgumentNullException.ThrowIfNull(parameters);

        return await compiler.Compile(
            sourceFilePath,
            parameters,
            cancellationToken
            ).ConfigureAwait(false);
    }

    /// <summary>
    /// Compiles OPA bundle from rego policy source code.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="source">Source file path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileSourceAsync(
        this IRegoCompiler compiler,
        string source,
        CompilationParameters parameters) => CompileSourceAsync(compiler, source, parameters, CancellationToken.None);

    /// <summary>
    /// Compiles OPA bundle from rego policy source code.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="source">Source file path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static async Task<Stream> CompileSourceAsync(
        this IRegoCompiler compiler,
        string source,
        CompilationParameters parameters,
        CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrEmpty(source);
        ArgumentNullException.ThrowIfNull(parameters);

        using var bundle = new MemoryStream();
        var bw = new BundleWriter(bundle);

        await using (bw.ConfigureAwait(false))
        {
            bw.WriteEntry(source, "policy.rego");
        }

        bundle.Seek(0, SeekOrigin.Begin);

        return await compiler.Compile(
            bundle,
            parameters.IsBundle ? parameters : parameters with { IsBundle = true },
            cancellationToken
            ).ConfigureAwait(false);
    }

    /// <summary>
    /// Compiles OPA bundle from path.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="path">Bundle directory or bundle archive path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileBundleAsync(
        this IRegoCompiler compiler,
        string path,
        CompilationParameters parameters) => CompileBundleAsync(compiler, path, parameters, CancellationToken.None);

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="path">Bundle directory or bundle archive path.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileBundleAsync(
        this IRegoCompiler compiler,
        string path,
        CompilationParameters parameters,
        CancellationToken cancellationToken)
    {
        ArgumentException.ThrowIfNullOrEmpty(path);
        ArgumentNullException.ThrowIfNull(parameters);

        return compiler.Compile(
            path,
            parameters.IsBundle ? parameters : parameters with { IsBundle = true },
            cancellationToken
            );
    }

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="bundle">Rego bundle stream.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileBundleAsync(
        this IRegoCompiler compiler,
        Stream bundle,
        CompilationParameters parameters) => CompileBundleAsync(compiler, bundle, parameters, CancellationToken.None);

    /// <summary>
    /// Compiles OPA bundle from rego bundle stream.
    /// </summary>
    /// <param name="compiler">Compiler instance.</param>
    /// <param name="bundle">Rego bundle stream.</param>
    /// <param name="parameters">Compiler parameters.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    /// <remarks>This method always compiles contents as bundle.</remarks>
    /// <returns>Compiled OPA bundle stream.</returns>
    public static Task<Stream> CompileBundleAsync(
        this IRegoCompiler compiler,
        Stream bundle,
        CompilationParameters parameters,
        CancellationToken cancellationToken)
    {
        ArgumentNullException.ThrowIfNull(bundle);
        ArgumentNullException.ThrowIfNull(parameters);

        return compiler.Compile(
            bundle,
            parameters.IsBundle ? parameters : parameters with { IsBundle = true },
            cancellationToken
            );
    }
}

1	using JetBrains.Annotations;
2
3	namespace OpaDotNet.Compilation.Abstractions;
4
5	/// <summary>
6	/// Compilation extensions.
7	/// </summary>
8	[PublicAPI]
9	public static class RegoCompilerExtensions
10	{
11	/// <summary>
12	/// Compiles OPA bundle from bundle directory.
13	/// </summary>
14	/// <param name="compiler">Compiler instance.</param>
15	/// <param name="bundlePath">Bundle directory or bundle archive path.</param>
16	/// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
17	/// <param name="capabilitiesFilePath">
18	/// Capabilities file that defines the built-in functions and other language features that policies may depend on.
19	/// </param>
20	/// <param name="cancellationToken">Cancellation token.</param>
21	/// <returns>Compiled OPA bundle stream.</returns>
22	[Obsolete("Use IRegoCompiler.CompileBundleAsync instead")]
23	public static async Task<Stream> CompileBundle(
24	this IRegoCompiler compiler,
25	string bundlePath,
26	IEnumerable<string>? entrypoints = null,
27	string? capabilitiesFilePath = null,
28	CancellationToken cancellationToken = default)
29	{
30	ArgumentException.ThrowIfNullOrEmpty(bundlePath);	×
31
32	var opts = new CompilationParameters	×
33	{	×
34	Entrypoints = entrypoints?.ToList(),	×
35	CapabilitiesFilePath = capabilitiesFilePath,	×
36	IsBundle = true,	×
37	};	×
38
39	return await compiler.CompileBundleAsync(bundlePath, opts, cancellationToken).ConfigureAwait(false);	×
40	}	×
41
42	/// <summary>
43	/// Compiles OPA bundle from rego policy source file.
44	/// </summary>
45	/// <param name="compiler">Compiler instance.</param>
46	/// <param name="sourceFilePath">Source file path.</param>
47	/// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
48	/// <param name="cancellationToken">Cancellation token.</param>
49	/// <returns>Compiled OPA bundle stream.</returns>
50	[Obsolete("Use IRegoCompiler.CompileFileAsync instead")]
51	public static Task<Stream> CompileFile(
52	this IRegoCompiler compiler,
53	string sourceFilePath,
54	IEnumerable<string>? entrypoints = null,
55	CancellationToken cancellationToken = default)
56	{
57	ArgumentException.ThrowIfNullOrEmpty(sourceFilePath);	×
58
59	var opts = new CompilationParameters { Entrypoints = entrypoints?.ToList() };	×
60	return compiler.Compile(sourceFilePath, opts, cancellationToken);	×
61	}
62
63	/// <summary>
64	/// Compiles OPA bundle from rego bundle stream.
65	/// </summary>
66	/// <param name="compiler">Compiler instance.</param>
67	/// <param name="bundle">Rego bundle stream.</param>
68	/// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
69	/// <param name="capabilitiesJson">
70	/// Capabilities json that defines the built-in functions and other language features that policies may depend on.
71	/// </param>
72	/// <param name="cancellationToken">Cancellation token.</param>
73	/// <returns>Compiled OPA bundle stream.</returns>
74	[Obsolete("Use IRegoCompiler.CompileBundleAsync instead")]
75	public static Task<Stream> CompileStream(
76	this IRegoCompiler compiler,
77	Stream bundle,
78	IEnumerable<string>? entrypoints = null,
79	Stream? capabilitiesJson = null,
80	CancellationToken cancellationToken = default)
81	{
82	ArgumentNullException.ThrowIfNull(bundle);	×
83
84	var capsMem = Memory<byte>.Empty;	×
85
86	if (capabilitiesJson != null)	×
87	{
88	capsMem = new byte[(int)capabilitiesJson.Length];	×
89	_ = capabilitiesJson.Read(capsMem.Span);	×
90	}
91
92	var opts = new CompilationParameters	×
93	{	×
94	Entrypoints = entrypoints?.ToList(),	×
95	CapabilitiesBytes = capsMem,	×
96	IsBundle = true,	×
97	};	×
98
99	return compiler.CompileBundleAsync(bundle, opts, cancellationToken);	×
100	}
101
102	/// <summary>
103	/// Compiles OPA bundle from rego policy source code.
104	/// </summary>
105	/// <param name="compiler">Compiler instance.</param>
106	/// <param name="source">Source file path.</param>
107	/// <param name="entrypoints">Which documents (entrypoints) will be queried when asking for policy decisions.</param>
108	/// <param name="cancellationToken">Cancellation token.</param>
109	/// <returns>Compiled OPA bundle stream.</returns>
110	[Obsolete("Use IRegoCompiler.CompileSourceAsync instead")]
111	public static Task<Stream> CompileSource(
112	this IRegoCompiler compiler,
113	string source,
114	IEnumerable<string>? entrypoints = null,
115	CancellationToken cancellationToken = default)
116	{
117	var opts = new CompilationParameters	×
118	{	×
119	Entrypoints = entrypoints?.ToList(),	×
120	IsBundle = true,	×
121	};	×
122
123	return compiler.CompileSourceAsync(source, opts, cancellationToken);	×
124	}
125
126	/// <summary>
127	/// Compiles OPA bundle from rego bundle stream.
128	/// </summary>
129	/// <param name="compiler">Compiler instance.</param>
130	/// <param name="sourceFilePath">Source file path.</param>
131	/// <param name="parameters">Compiler parameters.</param>
132	/// <returns>Compiled OPA bundle stream.</returns>
133	public static Task<Stream> CompileFileAsync(
134	this IRegoCompiler compiler,
135	string sourceFilePath,
136	CompilationParameters parameters) => CompileFileAsync(compiler, sourceFilePath, parameters, CancellationToken.None);	95✔
137
138	/// <summary>
139	/// Compiles OPA bundle from rego bundle stream.
140	/// </summary>
141	/// <param name="compiler">Compiler instance.</param>
142	/// <param name="sourceFilePath">Source file path.</param>
143	/// <param name="parameters">Compiler parameters.</param>
144	/// <param name="cancellationToken">Cancellation token.</param>
145	/// <returns>Compiled OPA bundle stream.</returns>
146	public static async Task<Stream> CompileFileAsync(
147	this IRegoCompiler compiler,
148	string sourceFilePath,
149	CompilationParameters parameters,
150	CancellationToken cancellationToken)
151	{
152	ArgumentException.ThrowIfNullOrEmpty(sourceFilePath);	95✔
153	ArgumentNullException.ThrowIfNull(parameters);	95✔
154
155	return await compiler.Compile(	95✔
156	sourceFilePath,	95✔
157	parameters,	95✔
158	cancellationToken	95✔
159	).ConfigureAwait(false);	95✔
160	}	94✔
161
162	/// <summary>
163	/// Compiles OPA bundle from rego policy source code.
164	/// </summary>
165	/// <param name="compiler">Compiler instance.</param>
166	/// <param name="source">Source file path.</param>
167	/// <param name="parameters">Compiler parameters.</param>
168	/// <remarks>This method always compiles contents as bundle.</remarks>
169	/// <returns>Compiled OPA bundle stream.</returns>
170	public static Task<Stream> CompileSourceAsync(
171	this IRegoCompiler compiler,
172	string source,
173	CompilationParameters parameters) => CompileSourceAsync(compiler, source, parameters, CancellationToken.None);	572✔
174
175	/// <summary>
176	/// Compiles OPA bundle from rego policy source code.
177	/// </summary>
178	/// <param name="compiler">Compiler instance.</param>
179	/// <param name="source">Source file path.</param>
180	/// <param name="parameters">Compiler parameters.</param>
181	/// <param name="cancellationToken">Cancellation token.</param>
182	/// <remarks>This method always compiles contents as bundle.</remarks>
183	/// <returns>Compiled OPA bundle stream.</returns>
184	public static async Task<Stream> CompileSourceAsync(
185	this IRegoCompiler compiler,
186	string source,
187	CompilationParameters parameters,
188	CancellationToken cancellationToken)
189	{
190	ArgumentException.ThrowIfNullOrEmpty(source);	572✔
191	ArgumentNullException.ThrowIfNull(parameters);	572✔
192
193	using var bundle = new MemoryStream();	572✔
194	var bw = new BundleWriter(bundle);	572✔
195
196	await using (bw.ConfigureAwait(false))	572✔
197	{
198	bw.WriteEntry(source, "policy.rego");	572✔
199	}
200
201	bundle.Seek(0, SeekOrigin.Begin);	572✔
202
203	return await compiler.Compile(	572!
204	bundle,	572✔
205	parameters.IsBundle ? parameters : parameters with { IsBundle = true },	572✔
206	cancellationToken	572✔
207	).ConfigureAwait(false);	572✔
208	}	570✔
209
210	/// <summary>
211	/// Compiles OPA bundle from path.
212	/// </summary>
213	/// <param name="compiler">Compiler instance.</param>
214	/// <param name="path">Bundle directory or bundle archive path.</param>
215	/// <param name="parameters">Compiler parameters.</param>
216	/// <remarks>This method always compiles contents as bundle.</remarks>
217	/// <returns>Compiled OPA bundle stream.</returns>
218	public static Task<Stream> CompileBundleAsync(
219	this IRegoCompiler compiler,
220	string path,
221	CompilationParameters parameters) => CompileBundleAsync(compiler, path, parameters, CancellationToken.None);	93✔
222
223	/// <summary>
224	/// Compiles OPA bundle from rego bundle stream.
225	/// </summary>
226	/// <param name="compiler">Compiler instance.</param>
227	/// <param name="path">Bundle directory or bundle archive path.</param>
228	/// <param name="parameters">Compiler parameters.</param>
229	/// <param name="cancellationToken">Cancellation token.</param>
230	/// <remarks>This method always compiles contents as bundle.</remarks>
231	/// <returns>Compiled OPA bundle stream.</returns>
232	public static Task<Stream> CompileBundleAsync(
233	this IRegoCompiler compiler,
234	string path,
235	CompilationParameters parameters,
236	CancellationToken cancellationToken)
237	{
238	ArgumentException.ThrowIfNullOrEmpty(path);	93✔
239	ArgumentNullException.ThrowIfNull(parameters);	93✔
240
241	return compiler.Compile(	93!
242	path,	93✔
243	parameters.IsBundle ? parameters : parameters with { IsBundle = true },	93✔
244	cancellationToken	93✔
245	);	93✔
246	}
247
248	/// <summary>
249	/// Compiles OPA bundle from rego bundle stream.
250	/// </summary>
251	/// <param name="compiler">Compiler instance.</param>
252	/// <param name="bundle">Rego bundle stream.</param>
253	/// <param name="parameters">Compiler parameters.</param>
254	/// <remarks>This method always compiles contents as bundle.</remarks>
255	/// <returns>Compiled OPA bundle stream.</returns>
256	public static Task<Stream> CompileBundleAsync(
257	this IRegoCompiler compiler,
258	Stream bundle,
259	CompilationParameters parameters) => CompileBundleAsync(compiler, bundle, parameters, CancellationToken.None);	20✔
260
261	/// <summary>
262	/// Compiles OPA bundle from rego bundle stream.
263	/// </summary>
264	/// <param name="compiler">Compiler instance.</param>
265	/// <param name="bundle">Rego bundle stream.</param>
266	/// <param name="parameters">Compiler parameters.</param>
267	/// <param name="cancellationToken">Cancellation token.</param>
268	/// <remarks>This method always compiles contents as bundle.</remarks>
269	/// <returns>Compiled OPA bundle stream.</returns>
270	public static Task<Stream> CompileBundleAsync(
271	this IRegoCompiler compiler,
272	Stream bundle,
273	CompilationParameters parameters,
274	CancellationToken cancellationToken)
275	{
276	ArgumentNullException.ThrowIfNull(bundle);	20✔
277	ArgumentNullException.ThrowIfNull(parameters);	20✔
278
279	return compiler.Compile(	20!
280	bundle,	20✔
281	parameters.IsBundle ? parameters : parameters with { IsBundle = true },	20✔
282	cancellationToken	20✔
283	);	20✔
284	}
285	}

me-viper / OpaDotNet / 11512106788

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous