#269

pending completion

Build # #269

Build Type

push

appveyor

Committed by

web-flow

Commit Message

<a href="https://github.com/Badgerati/Pode/commit/<a class=hub.com/Badgerati/Pode/commit/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/<a class="double-link" href="https://git"><a class=hub.com/Badgerati/Pode/commit/8fbb80c74ede81e36f9009e4cd2f0ae21b59a5c6">8fbb80c74">&lt;a href=&quot;https://github.com/Badgerati/Pode/commit/</a><a class="double-link" href="https://github.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Badgerati/Pode/commit/8fbb80c74ede81e36f9009e4cd2f0ae21b59a5c6">8fbb80c74</a><a href="https://github.com/Badgerati/Pode/commit/8fbb80c74ede81e36f9009e4cd2f0ae21b59a5c6">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Badgerati/Pode/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Badgerati/Pode/commit/8fbb80c74ede81e36f9009e4cd2f0ae21b59a5c6&quot;&gt;8fbb80c74&lt;/a&gt;&lt;a href=&quot;https://github.com/Badgerati/Pode/commit/8fbb80c74ede81e36f9009e4cd2f0ae21b59a5c6&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Badgerati/Pode/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/Badgerati/Pode/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=... (continued)

Run Details

139 of 139 new or added lines in 7 files covered. (100.0%)

2092 of 3801 relevant lines covered (55.04%)

0.69 hits per line

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

67.59

/src/Private/Routes.ps1

function Get-PodeRoute
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateSet('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE', 'STATIC', '*')]
        [string]
        $Method,

        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]
        $Route,

        [Parameter()]
        [string]
        $Protocol,

        [Parameter()]
        [string]
        $Endpoint,

        [switch]
        $CheckWildMethod
    )

    # first, if supplied, check the wildcard method
    if ($CheckWildMethod -and $PodeContext.Server.Routes['*'].Count -ne 0) {
        $found = Get-PodeRoute -Method '*' -Route $Route -Protocol $Protocol -Endpoint $Endpoint
        if ($null -ne $found) {
            return $found
        }
    }

    # is this a static route?
    $isStatic = ($Method -ieq 'static')

    # first ensure we have the method
    $_method = $PodeContext.Server.Routes[$Method]
    if ($null -eq $_method) {
        return $null
    }

    # if we have a perfect match for the route, return it if the protocol is right
    $found = Get-PodeRouteByUrl -Routes $_method[$Route] -Protocol $Protocol -Endpoint $Endpoint
    if (!$isStatic -and $null -ne $found) {
        return @{
            'Logic' = $found.Logic;
            'Middleware' = $found.Middleware;
            'Protocol' = $found.Protocol;
            'Endpoint' = $found.Endpoint;
            'ContentType' = $found.ContentType;
            'ErrorType' = $found.ErrorType;
            'Parameters' = $null;
        }
    }

    # otherwise, attempt to match on regex parameters
    else {
        $valid = @(foreach ($key in $_method.Keys) {
            if ($Route -imatch "^$($key)$") {
                $key
            }
        })[0]

        if ($null -eq $valid) {
            return $null
        }

        $found = Get-PodeRouteByUrl -Routes $_method[$valid] -Protocol $Protocol -Endpoint $Endpoint
        if ($null -eq $found) {
            return $null
        }

        $Route -imatch "$($valid)$" | Out-Null

        if ($isStatic) {
            return @{
                'Path' = $found.Path;
                'Defaults' = $found.Defaults;
                'Protocol' = $found.Protocol;
                'Endpoint' = $found.Endpoint;
                'Download' = $found.Download;
                'File' = $Matches['file'];
            }
        }
        else {
            return @{
                'Logic' = $found.Logic;
                'Middleware' = $found.Middleware;
                'Protocol' = $found.Protocol;
                'Endpoint' = $found.Endpoint;
                'ContentType' = $found.ContentType;
                'ErrorType' = $found.ErrorType;
                'Parameters' = $Matches;
            }
        }
    }
}

function Get-PodeStaticRoutePath
{
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]
        $Route,

        [Parameter()]
        [string]
        $Protocol,

        [Parameter()]
        [string]
        $Endpoint
    )

    # attempt to get a static route for the path
    $found = Get-PodeRoute -Method 'static' -Route $Route -Protocol $Protocol -Endpoint $Endpoint
    $path = $null
    $download = $false

    # if we have a defined static route, use that
    if ($null -ne $found) {
        # is the found route set as download only?
        if ($found.Download) {
            $download = $true
            $path = (Join-Path $found.Path (Protect-PodeValue -Value $found.File -Default ([string]::Empty)))
        }

        # if there's no file, we need to check defaults
        elseif (!(Test-PodePathIsFile $found.File) -and (Get-PodeCount @($found.Defaults)) -gt 0)
        {
            $found.File = (Protect-PodeValue -Value $found.File -Default ([string]::Empty))

            if ((Get-PodeCount @($found.Defaults)) -eq 1) {
                $found.File = Join-PodePaths @($found.File, @($found.Defaults)[0])
            }
            else {
                foreach ($def in $found.Defaults) {
                    if (Test-PodePath (Join-Path $found.Path $def) -NoStatus) {
                        $found.File = Join-PodePaths @($found.File, $def)
                        break
                    }
                }
            }
        }

        $path = (Join-Path $found.Path $found.File)
    }

    # else, use the public static directory (but only if path is a file, and a public dir is present)
    elseif ((Test-PodePathIsFile $Route) -and ![string]::IsNullOrWhiteSpace($PodeContext.Server.InbuiltDrives['public'])) {
        $path = (Join-Path $PodeContext.Server.InbuiltDrives['public'] $Route)
    }

    # return the route details
    return @{
        'Path' = $path;
        'Download' = $download;
    }
}

function Get-PodeRouteByUrl
{
    param (
        [Parameter()]
        [object[]]
        $Routes,

        [Parameter()]
        [string]
        $Protocol,

        [Parameter()]
        [string]
        $Endpoint
    )

    # get the value routes
    $rs = @(foreach ($route in $Routes) {
        if (
            (($route.Protocol -ieq $Protocol) -or [string]::IsNullOrWhiteSpace($route.Protocol)) -and
            ([string]::IsNullOrWhiteSpace($route.Endpoint) -or ($Endpoint -ilike $route.Endpoint))
        ) {
            $route
        }
    })

    if ($null -eq $rs[0]) {
        return $null
    }

    return @($rs | Sort-Object -Property { $_.Protocol }, { $_.Endpoint } -Descending)[0]
}

function Update-PodeRoutePlaceholders
{
    param (
        [Parameter(Mandatory=$true)]
        [string]
        $Path
    )

    # replace placeholder parameters with regex
    $placeholder = '\:(?<tag>[\w]+)'
    if ($Path -imatch $placeholder) {
        $Path = [regex]::Escape($Path)
    }

    while ($Path -imatch $placeholder) {
        $Path = ($Path -ireplace $Matches[0], "(?<$($Matches['tag'])>[\w-_]+?)")
    }

    return $Path
}

function Update-PodeRouteSlashes
{
    param (
        [Parameter(Mandatory=$true)]
        [string]
        $Path,

        [switch]
        $Static
    )

    # ensure route starts with a '/'
    if (!$Path.StartsWith('/')) {
        $Path = "/$($Path)"
    }

    if ($Static) {
        # ensure the static route ends with '/{0,1}.*'
        $Path = $Path.TrimEnd('/*')
        $Path = "$($Path)[/]{0,1}(?<file>*)"
    }

    # replace * with .*
    $Path = ($Path -ireplace '\*', '.*')
    return $Path
}

function Split-PodeRouteQuery
{
    param (
        [Parameter(Mandatory=$true)]
        [string]
        $Path
    )

    return ($Path -isplit "\?")[0]
}

function Get-PodeStaticRouteDefaults
{
    if (!(Test-IsEmpty $PodeContext.Server.Web.Static.Defaults)) {
        return @($PodeContext.Server.Web.Static.Defaults)
    }

    return @(
        'index.html',
        'index.htm',
        'default.html',
        'default.htm'
    )
}

function Test-PodeRouteAndError
{
    param (
        [Parameter(Mandatory=$true)]
        [string]
        $Method,

        [Parameter(Mandatory=$true)]
        [string]
        $Path,

        [Parameter()]
        [string]
        $Protocol,

        [Parameter()]
        [string]
        $Endpoint
    )

    $found = @($PodeContext.Server.Routes[$Method][$Path])

    if (($found | Where-Object { $_.Protocol -ieq $Protocol -and $_.Endpoint -ieq $Endpoint } | Measure-Object).Count -eq 0) {
        return
    }

    $_url = $Protocol
    if (![string]::IsNullOrEmpty($_url) -and ![string]::IsNullOrWhiteSpace($Endpoint)) {
        $_url = "$($_url)://$($Endpoint)"
    }
    elseif (![string]::IsNullOrWhiteSpace($Endpoint)) {
        $_url = $Endpoint
    }

    if ([string]::IsNullOrEmpty($_url)) {
        throw "[$($Method)] $($Path): Already defined"
    }
    else {
        throw "[$($Method)] $($Path): Already defined for $($_url)"
    }
}

function Get-PodeEndpointByName
{
    param (
        [Parameter()]
        [string]
        $EndpointName,

        [switch]
        $ThrowError
    )

    # if an EndpointName was supplied, find it and use it
    if ([string]::IsNullOrWhiteSpace($EndpointName)) {
        return $null
    }

    # ensure it exists
    $found = ($PodeContext.Server.Endpoints | Where-Object {
        $_.Name -ieq $EndpointName
    } | Select-Object -First 1)

    if ($null -eq $found) {
        if ($ThrowError) {
            throw "Endpoint with name '$($EndpointName)' does not exist"
        }

        return $null
    }

    return $found
}

1	function Get-PodeRoute
2	{
3	param (
4	[Parameter(Mandatory=$true)]
5	[ValidateSet('DELETE', 'GET', 'HEAD', 'MERGE', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE', 'STATIC', '*')]
6	[string]
7	$Method,
8
9	[Parameter(Mandatory=$true)]
10	[ValidateNotNullOrEmpty()]
11	[string]
12	$Route,
13
14	[Parameter()]
15	[string]
16	$Protocol,
17
18	[Parameter()]
19	[string]
20	$Endpoint,
21
22	[switch]
23	$CheckWildMethod
24	)
25
26	# first, if supplied, check the wildcard method
27	if ($CheckWildMethod -and $PodeContext.Server.Routes['*'].Count -ne 0) {	1✔
28	$found = Get-PodeRoute -Method '*' -Route $Route -Protocol $Protocol -Endpoint $Endpoint	×
29	if ($null -ne $found) {	×
30	return $found	×
31	}
32	}
33
34	# is this a static route?
35	$isStatic = ($Method -ieq 'static')	2✔
36
37	# first ensure we have the method
38	$_method = $PodeContext.Server.Routes[$Method]	1✔
39	if ($null -eq $_method) {	1✔
40	return $null	1✔
41	}
42
43	# if we have a perfect match for the route, return it if the protocol is right
44	$found = Get-PodeRouteByUrl -Routes $_method[$Route] -Protocol $Protocol -Endpoint $Endpoint	1✔
45	if (!$isStatic -and $null -ne $found) {	1✔
46	return @{	1✔
47	'Logic' = $found.Logic;	1✔
48	'Middleware' = $found.Middleware;	1✔
49	'Protocol' = $found.Protocol;	1✔
50	'Endpoint' = $found.Endpoint;	1✔
51	'ContentType' = $found.ContentType;	1✔
52	'ErrorType' = $found.ErrorType;	1✔
53	'Parameters' = $null;	1✔
54	}
55	}
56
57	# otherwise, attempt to match on regex parameters
58	else {
59	$valid = @(foreach ($key in $_method.Keys) {	2✔
60	if ($Route -imatch "^$($key)$") {	2✔
61	$key	1✔
62	}
63	})[0]
64
65	if ($null -eq $valid) {	1✔
66	return $null	1✔
67	}
68
69	$found = Get-PodeRouteByUrl -Routes $_method[$valid] -Protocol $Protocol -Endpoint $Endpoint	1✔
70	if ($null -eq $found) {	1✔
71	return $null	×
72	}
73
74	$Route -imatch "$($valid)$" \| Out-Null	3✔
75
76	if ($isStatic) {	1✔
77	return @{	×
78	'Path' = $found.Path;	×
79	'Defaults' = $found.Defaults;	×
80	'Protocol' = $found.Protocol;	×
81	'Endpoint' = $found.Endpoint;	×
82	'Download' = $found.Download;	×
83	'File' = $Matches['file'];	×
84	}
85	}
86	else {
87	return @{	1✔
88	'Logic' = $found.Logic;	1✔
89	'Middleware' = $found.Middleware;	1✔
90	'Protocol' = $found.Protocol;	1✔
91	'Endpoint' = $found.Endpoint;	1✔
92	'ContentType' = $found.ContentType;	1✔
93	'ErrorType' = $found.ErrorType;	1✔
94	'Parameters' = $Matches;	1✔
95	}
96	}
97	}
98	}
99
100	function Get-PodeStaticRoutePath
101	{
102	param (
103	[Parameter(Mandatory=$true)]
104	[ValidateNotNullOrEmpty()]
105	[string]
106	$Route,
107
108	[Parameter()]
109	[string]
110	$Protocol,
111
112	[Parameter()]
113	[string]
114	$Endpoint
115	)
116
117	# attempt to get a static route for the path
118	$found = Get-PodeRoute -Method 'static' -Route $Route -Protocol $Protocol -Endpoint $Endpoint	×
119	$path = $null	×
120	$download = $false	×
121
122	# if we have a defined static route, use that
123	if ($null -ne $found) {	×
124	# is the found route set as download only?
125	if ($found.Download) {	×
126	$download = $true	×
127	$path = (Join-Path $found.Path (Protect-PodeValue -Value $found.File -Default ([string]::Empty)))	×
128	}
129
130	# if there's no file, we need to check defaults
131	elseif (!(Test-PodePathIsFile $found.File) -and (Get-PodeCount @($found.Defaults)) -gt 0)	×
132	{
133	$found.File = (Protect-PodeValue -Value $found.File -Default ([string]::Empty))	×
134
135	if ((Get-PodeCount @($found.Defaults)) -eq 1) {	×
136	$found.File = Join-PodePaths @($found.File, @($found.Defaults)[0])	×
137	}
138	else {
139	foreach ($def in $found.Defaults) {	×
140	if (Test-PodePath (Join-Path $found.Path $def) -NoStatus) {	×
141	$found.File = Join-PodePaths @($found.File, $def)	×
142	break
143	}
144	}
145	}
146	}
147
148	$path = (Join-Path $found.Path $found.File)	×
149	}
150
151	# else, use the public static directory (but only if path is a file, and a public dir is present)
152	elseif ((Test-PodePathIsFile $Route) -and ![string]::IsNullOrWhiteSpace($PodeContext.Server.InbuiltDrives['public'])) {	×
153	$path = (Join-Path $PodeContext.Server.InbuiltDrives['public'] $Route)	×
154	}
155
156	# return the route details
157	return @{	×
158	'Path' = $path;	×
159	'Download' = $download;	×
160	}
161	}
162
163	function Get-PodeRouteByUrl
164	{
165	param (
166	[Parameter()]
167	[object[]]
168	$Routes,
169
170	[Parameter()]
171	[string]
172	$Protocol,
173
174	[Parameter()]
175	[string]
176	$Endpoint
177	)
178
179	# get the value routes
180	$rs = @(foreach ($route in $Routes) {	2✔
181	if (
182	(($route.Protocol -ieq $Protocol) -or [string]::IsNullOrWhiteSpace($route.Protocol)) -and	3✔
183	([string]::IsNullOrWhiteSpace($route.Endpoint) -or ($Endpoint -ilike $route.Endpoint))	2✔
184	) {
185	$route	1✔
186	}
187	})
188
189	if ($null -eq $rs[0]) {	1✔
190	return $null	1✔
191	}
192
193	return @($rs \| Sort-Object -Property { $_.Protocol }, { $_.Endpoint } -Descending)[0]	5✔
194	}
195
196	function Update-PodeRoutePlaceholders
197	{
198	param (
199	[Parameter(Mandatory=$true)]
200	[string]
201	$Path
202	)
203
204	# replace placeholder parameters with regex
205	$placeholder = '\:(?<tag>[\w]+)'	1✔
206	if ($Path -imatch $placeholder) {	1✔
207	$Path = [regex]::Escape($Path)	1✔
208	}
209
210	while ($Path -imatch $placeholder) {	1✔
211	$Path = ($Path -ireplace $Matches[0], "(?<$($Matches['tag'])>[\w-_]+?)")	3✔
212	}
213
214	return $Path	1✔
215	}
216
217	function Update-PodeRouteSlashes
218	{
219	param (
220	[Parameter(Mandatory=$true)]
221	[string]
222	$Path,
223
224	[switch]
225	$Static
226	)
227
228	# ensure route starts with a '/'
229	if (!$Path.StartsWith('/')) {	1✔
230	$Path = "/$($Path)"	×
231	}
232
233	if ($Static) {	1✔
234	# ensure the static route ends with '/{0,1}.*'
235	$Path = $Path.TrimEnd('/*')	1✔
236	$Path = "$($Path)[/]{0,1}(?<file>*)"	2✔
237	}
238
239	# replace * with .*
240	$Path = ($Path -ireplace '\', '.')	2✔
241	return $Path	1✔
242	}
243
244	function Split-PodeRouteQuery
245	{
246	param (
247	[Parameter(Mandatory=$true)]
248	[string]
249	$Path
250	)
251
252	return ($Path -isplit "\?")[0]	2✔
253	}
254
255	function Get-PodeStaticRouteDefaults
256	{
257	if (!(Test-IsEmpty $PodeContext.Server.Web.Static.Defaults)) {	2✔
258	return @($PodeContext.Server.Web.Static.Defaults)	×
259	}
260
261	return @(	1✔
262	'index.html',	1✔
263	'index.htm',
264	'default.html',
265	'default.htm'
266	)
267	}
268
269	function Test-PodeRouteAndError
270	{
271	param (
272	[Parameter(Mandatory=$true)]
273	[string]
274	$Method,
275
276	[Parameter(Mandatory=$true)]
277	[string]
278	$Path,
279
280	[Parameter()]
281	[string]
282	$Protocol,
283
284	[Parameter()]
285	[string]
286	$Endpoint
287	)
288
289	$found = @($PodeContext.Server.Routes[$Method][$Path])	2✔
290
291	if (($found \| Where-Object { $_.Protocol -ieq $Protocol -and $_.Endpoint -ieq $Endpoint } \| Measure-Object).Count -eq 0) {	5✔
292	return
293	}
294
295	$_url = $Protocol	1✔
296	if (![string]::IsNullOrEmpty($_url) -and ![string]::IsNullOrWhiteSpace($Endpoint)) {	1✔
297	$_url = "$($_url)://$($Endpoint)"	3✔
298	}
299	elseif (![string]::IsNullOrWhiteSpace($Endpoint)) {	1✔
300	$_url = $Endpoint	1✔
301	}
302
303	if ([string]::IsNullOrEmpty($_url)) {	1✔
304	throw "[$($Method)] $($Path): Already defined"	3✔
305	}
306	else {
307	throw "[$($Method)] $($Path): Already defined for $($_url)"	4✔
308	}
309	}
310
311	function Get-PodeEndpointByName
312	{
313	param (
314	[Parameter()]
315	[string]
316	$EndpointName,
317
318	[switch]
319	$ThrowError
320	)
321
322	# if an EndpointName was supplied, find it and use it
323	if ([string]::IsNullOrWhiteSpace($EndpointName)) {	1✔
324	return $null	1✔
325	}
326
327	# ensure it exists
328	$found = ($PodeContext.Server.Endpoints \| Where-Object {	3✔
329	$_.Name -ieq $EndpointName	1✔
330	} \| Select-Object -First 1)	1✔
331
332	if ($null -eq $found) {	1✔
333	if ($ThrowError) {	1✔
334	throw "Endpoint with name '$($EndpointName)' does not exist"	2✔
335	}
336
337	return $null	×
338	}
339
340	return $found	×
341	}

Badgerati / Pode / #269

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