mirror of
https://github.com/Micke-K/IntuneManagement.git
synced 2026-09-28 19:05:38 +02:00
562 lines
25 KiB
PowerShell
562 lines
25 KiB
PowerShell
# Offline Graph for the mock tenant.
|
|
#
|
|
# Serves Microsoft Graph requests from JSON files on disk so the whole
|
|
# application can run - sign in, browse, view, copy, import, delete, document -
|
|
# with no tenant and no network. Used for screenshots, demos and UI work on a
|
|
# train. Wired in through the AuthenticationMock provider
|
|
# (Classes/AuthenticationMock.ps1), which hands every request here via the
|
|
# RoutesAllRequests capability; nothing else in the product knows about it.
|
|
#
|
|
# Data folder layout (IM_MOCK_DATA):
|
|
#
|
|
# settings.json settings store for the session (IM_SETTINGS_FILE)
|
|
# tenant.json TenantId, TenantName, UPN, DisplayName, UserId
|
|
# graph/<path>.json one file per Graph path, e.g.
|
|
# graph/organization.json { "value": [ {...} ] } a collection
|
|
# graph/me.json { ... } a single object
|
|
# graph/deviceManagement/deviceConfigurations.json
|
|
#
|
|
# A collection file's items are addressable as <path>/<id> and <path>/<id>/<prop>
|
|
# (assignments, settings, ...), $filter / $expand / $top are honoured on list
|
|
# calls, $batch is unpacked, and POST / PATCH / DELETE mutate the in-memory copy
|
|
# so Copy, Import and Delete work for the length of the session. The files on
|
|
# disk are never written to.
|
|
#
|
|
# Everything unknown answers 200 with an empty collection rather than 404:
|
|
# the product treats an empty list as "nothing here", which is the right
|
|
# rendering for a path the mock data simply does not cover.
|
|
|
|
$script:MockGraphStore = $null
|
|
|
|
# Load (or reload) the data folder. Keys are Graph paths without a leading
|
|
# slash: 'deviceManagement/deviceConfigurations'.
|
|
function Initialize-MockGraphStore {
|
|
[CmdletBinding()]
|
|
param([Parameter(Mandatory)][string]$Root)
|
|
|
|
$graphRoot = Join-Path $Root "graph"
|
|
$store = @{
|
|
Root = $Root
|
|
Collections = @{} # path -> List[object]
|
|
Singles = @{} # path -> object
|
|
}
|
|
if(Test-Path -LiteralPath $graphRoot -PathType Container) {
|
|
foreach($file in (Get-ChildItem -LiteralPath $graphRoot -Filter *.json -Recurse -File)) {
|
|
$rel = $file.FullName.Substring($graphRoot.Length).TrimStart('\', '/')
|
|
$key = ($rel -replace '\.json$', '') -replace '\\', '/'
|
|
try {
|
|
$data = [IO.File]::ReadAllText($file.FullName) | ConvertFrom-Json
|
|
}
|
|
catch {
|
|
Write-Log "Mock Graph: cannot parse $($file.FullName): $($_.Exception.Message)" 3
|
|
continue
|
|
}
|
|
if($data.PSObject.Properties['value'] -and $data.value -is [array]) {
|
|
$list = [System.Collections.Generic.List[object]]::new()
|
|
foreach($item in $data.value) { $list.Add($item) }
|
|
$store.Collections[$key] = $list
|
|
}
|
|
else {
|
|
$store.Singles[$key] = $data
|
|
}
|
|
}
|
|
}
|
|
$script:MockGraphStore = $store
|
|
Write-Log "Mock Graph: loaded $($store.Collections.Count) collections and $($store.Singles.Count) objects from $graphRoot"
|
|
return $store
|
|
}
|
|
|
|
function Get-MockGraphStore {
|
|
return $script:MockGraphStore
|
|
}
|
|
|
|
# Split an absolute or relative Graph URL into its path (no host, no version,
|
|
# no leading slash) and a query hashtable with unescaped values.
|
|
function Split-MockGraphUrl {
|
|
[CmdletBinding()]
|
|
param([Parameter(Mandatory)][string]$Url)
|
|
|
|
$path = $Url
|
|
$query = ""
|
|
$q = $path.IndexOf('?')
|
|
if($q -ge 0) { $query = $path.Substring($q + 1); $path = $path.Substring(0, $q) }
|
|
$path = $path -replace '^https?://[^/]+/', ''
|
|
$path = $path -replace '^(beta|v1\.0)/', ''
|
|
$path = $path.Trim('/')
|
|
$path = [Uri]::UnescapeDataString($path)
|
|
|
|
$params = @{}
|
|
if($query) {
|
|
foreach($pair in $query.Split('&')) {
|
|
if(-not $pair) { continue }
|
|
$eq = $pair.IndexOf('=')
|
|
if($eq -lt 0) { $params[[Uri]::UnescapeDataString($pair)] = ""; continue }
|
|
$name = [Uri]::UnescapeDataString($pair.Substring(0, $eq))
|
|
$value = [Uri]::UnescapeDataString($pair.Substring($eq + 1).Replace('+', ' '))
|
|
$params[$name] = $value
|
|
}
|
|
}
|
|
return [PSCustomObject]@{ Path = $path; Query = $params }
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# OData $filter - the subset the policy types actually send:
|
|
# a eq 'x' a ne 'x' a eq true isof('microsoft.graph.t')
|
|
# contains(tolower(a),'x') startswith(a,'x') endswith(a,'x')
|
|
# and / or / not, parentheses, cast segments (microsoft.graph.t/prop)
|
|
# Anything the parser cannot read matches everything (logged once), which
|
|
# keeps a list visible rather than empty when a new clause shape appears.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
function ConvertTo-MockFilterTokens {
|
|
param([string]$Filter)
|
|
$tokens = [System.Collections.Generic.List[object]]::new()
|
|
$i = 0
|
|
$n = $Filter.Length
|
|
while($i -lt $n) {
|
|
$c = $Filter[$i]
|
|
if([char]::IsWhiteSpace($c)) { $i++; continue }
|
|
if($c -eq '(' -or $c -eq ')' -or $c -eq ',') {
|
|
$tokens.Add([PSCustomObject]@{ Type = 'punct'; Value = [string]$c }); $i++; continue
|
|
}
|
|
if($c -eq "'") {
|
|
$sb = [System.Text.StringBuilder]::new()
|
|
$i++
|
|
while($i -lt $n) {
|
|
if($Filter[$i] -eq "'") {
|
|
if($i + 1 -lt $n -and $Filter[$i + 1] -eq "'") { [void]$sb.Append("'"); $i += 2; continue }
|
|
break
|
|
}
|
|
[void]$sb.Append($Filter[$i]); $i++
|
|
}
|
|
$i++
|
|
$tokens.Add([PSCustomObject]@{ Type = 'string'; Value = $sb.ToString() }); continue
|
|
}
|
|
$start = $i
|
|
while($i -lt $n -and -not [char]::IsWhiteSpace($Filter[$i]) -and $Filter[$i] -notin @('(', ')', ',', "'")) { $i++ }
|
|
$word = $Filter.Substring($start, $i - $start)
|
|
$lower = $word.ToLowerInvariant()
|
|
if($lower -in @('and', 'or', 'not', 'eq', 'ne', 'in')) { $tokens.Add([PSCustomObject]@{ Type = 'op'; Value = $lower }) }
|
|
elseif($lower -eq 'true' -or $lower -eq 'false') { $tokens.Add([PSCustomObject]@{ Type = 'bool'; Value = ($lower -eq 'true') }) }
|
|
elseif($lower -eq 'null') { $tokens.Add([PSCustomObject]@{ Type = 'null'; Value = $null }) }
|
|
elseif($word -match '^-?\d+(\.\d+)?$') { $tokens.Add([PSCustomObject]@{ Type = 'number'; Value = [double]$word }) }
|
|
else { $tokens.Add([PSCustomObject]@{ Type = 'ident'; Value = $word }) }
|
|
}
|
|
return ,$tokens
|
|
}
|
|
|
|
# Resolve 'a/b/c' against an item. A segment that names a type
|
|
# ('microsoft.graph.androidManagedStoreAppConfiguration') is a cast: it yields
|
|
# $null unless the item is of that type.
|
|
function Get-MockFilterPropertyValue {
|
|
param($Item, [string]$Path)
|
|
$current = $Item
|
|
foreach($segment in $Path.Split('/')) {
|
|
if($null -eq $current) { return $null }
|
|
if($segment -like 'microsoft.graph.*') {
|
|
$type = [string]$current.'@odata.type'
|
|
if($type -ne "#$segment") { return $null }
|
|
continue
|
|
}
|
|
$prop = $current.PSObject.Properties[$segment]
|
|
if(-not $prop) { return $null }
|
|
$current = $prop.Value
|
|
}
|
|
return $current
|
|
}
|
|
|
|
# Recursive-descent evaluator. $State is @{ Tokens; Pos; Item }.
|
|
function Invoke-MockFilterOr {
|
|
param($State)
|
|
$left = Invoke-MockFilterAnd $State
|
|
while($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'op' -and $State.Tokens[$State.Pos].Value -eq 'or') {
|
|
$State.Pos++
|
|
$right = Invoke-MockFilterAnd $State
|
|
$left = ($left -or $right)
|
|
}
|
|
return $left
|
|
}
|
|
|
|
function Invoke-MockFilterAnd {
|
|
param($State)
|
|
$left = Invoke-MockFilterNot $State
|
|
while($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'op' -and $State.Tokens[$State.Pos].Value -eq 'and') {
|
|
$State.Pos++
|
|
$right = Invoke-MockFilterNot $State
|
|
$left = ($left -and $right)
|
|
}
|
|
return $left
|
|
}
|
|
|
|
function Invoke-MockFilterNot {
|
|
param($State)
|
|
if($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'op' -and $State.Tokens[$State.Pos].Value -eq 'not') {
|
|
$State.Pos++
|
|
return (-not (Invoke-MockFilterNot $State))
|
|
}
|
|
return (Invoke-MockFilterComparison $State)
|
|
}
|
|
|
|
# A value expression: literal, property path, or a function call. Returns the
|
|
# value (not a boolean) - comparisons happen one level up.
|
|
function Invoke-MockFilterValue {
|
|
param($State)
|
|
$token = $State.Tokens[$State.Pos]
|
|
$State.Pos++
|
|
switch($token.Type) {
|
|
'string' { return $token.Value }
|
|
'bool' { return $token.Value }
|
|
'null' { return $null }
|
|
'number' { return $token.Value }
|
|
}
|
|
if($token.Type -ne 'ident') { throw "Unexpected token '$($token.Value)'" }
|
|
|
|
$name = $token.Value
|
|
$isCall = ($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'punct' -and $State.Tokens[$State.Pos].Value -eq '(')
|
|
if(-not $isCall) { return (Get-MockFilterPropertyValue $State.Item $name) }
|
|
|
|
$State.Pos++ # (
|
|
$args = [System.Collections.Generic.List[object]]::new()
|
|
while($true) {
|
|
$args.Add((Invoke-MockFilterValue $State))
|
|
$next = $State.Tokens[$State.Pos]
|
|
$State.Pos++
|
|
if($next.Type -eq 'punct' -and $next.Value -eq ')') { break }
|
|
if(-not ($next.Type -eq 'punct' -and $next.Value -eq ',')) { throw "Expected ',' or ')' in $name(...)" }
|
|
}
|
|
switch($name.ToLowerInvariant()) {
|
|
'tolower' { return ([string]$args[0]).ToLowerInvariant() }
|
|
'toupper' { return ([string]$args[0]).ToUpperInvariant() }
|
|
'contains' { return (([string]$args[0]).IndexOf([string]$args[1], [StringComparison]::OrdinalIgnoreCase) -ge 0) }
|
|
'startswith' { return (([string]$args[0]).StartsWith([string]$args[1], [StringComparison]::OrdinalIgnoreCase)) }
|
|
'endswith' { return (([string]$args[0]).EndsWith([string]$args[1], [StringComparison]::OrdinalIgnoreCase)) }
|
|
'isof' {
|
|
$type = [string]$args[-1]
|
|
return (([string]$State.Item.'@odata.type') -eq "#$type")
|
|
}
|
|
}
|
|
throw "Unsupported filter function '$name'"
|
|
}
|
|
|
|
function Invoke-MockFilterComparison {
|
|
param($State)
|
|
$token = $State.Tokens[$State.Pos]
|
|
if($token.Type -eq 'punct' -and $token.Value -eq '(') {
|
|
$State.Pos++
|
|
$inner = Invoke-MockFilterOr $State
|
|
$State.Pos++ # )
|
|
return $inner
|
|
}
|
|
$left = Invoke-MockFilterValue $State
|
|
if($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'op' -and $State.Tokens[$State.Pos].Value -eq 'in') {
|
|
# id in ('a','b') - the shape the group / filter name lookups send.
|
|
$State.Pos += 2 # in (
|
|
$found = $false
|
|
while($State.Pos -lt $State.Tokens.Count) {
|
|
$token = $State.Tokens[$State.Pos]
|
|
$State.Pos++
|
|
if($token.Type -eq 'punct' -and $token.Value -eq ')') { break }
|
|
if($token.Type -eq 'punct' -and $token.Value -eq ',') { continue }
|
|
if([string]$token.Value -ieq [string]$left) { $found = $true }
|
|
}
|
|
return $found
|
|
}
|
|
if($State.Pos -lt $State.Tokens.Count -and $State.Tokens[$State.Pos].Type -eq 'op' -and $State.Tokens[$State.Pos].Value -in @('eq', 'ne')) {
|
|
$op = $State.Tokens[$State.Pos].Value
|
|
$State.Pos++
|
|
$right = Invoke-MockFilterValue $State
|
|
$equal = if($null -eq $left -or $null -eq $right) { ($null -eq $left) -and ($null -eq $right) }
|
|
elseif($left -is [bool] -or $right -is [bool]) { [bool]$left -eq [bool]$right }
|
|
elseif($left -is [double] -or $right -is [double]) { [double]$left -eq [double]$right }
|
|
else { [string]$left -ieq [string]$right }
|
|
if($op -eq 'eq') { return $equal } else { return (-not $equal) }
|
|
}
|
|
return [bool]$left
|
|
}
|
|
|
|
$script:MockGraphFilterWarned = @{}
|
|
|
|
function Test-MockGraphFilter {
|
|
[CmdletBinding()]
|
|
param($Item, [string]$Filter)
|
|
|
|
if([string]::IsNullOrWhiteSpace($Filter)) { return $true }
|
|
try {
|
|
$state = @{ Tokens = (ConvertTo-MockFilterTokens $Filter); Pos = 0; Item = $Item }
|
|
return [bool](Invoke-MockFilterOr $state)
|
|
}
|
|
catch {
|
|
if(-not $script:MockGraphFilterWarned.ContainsKey($Filter)) {
|
|
$script:MockGraphFilterWarned[$Filter] = $true
|
|
Write-Log "Mock Graph: cannot evaluate `$filter '$Filter' ($($_.Exception.Message)) - returning every item" 2
|
|
}
|
|
return $true
|
|
}
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Request handling
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# Deep copy through JSON so a caller mutating the response never touches the store.
|
|
function Copy-MockGraphObject {
|
|
param($Object)
|
|
if($null -eq $Object) { return $null }
|
|
return ($Object | ConvertTo-Json -Depth 50 -Compress | ConvertFrom-Json)
|
|
}
|
|
|
|
function New-MockGraphResult {
|
|
param([int]$Status, $Body)
|
|
return [PSCustomObject]@{ Status = $Status; Body = $Body }
|
|
}
|
|
|
|
function Get-MockGraphItem {
|
|
param($Collection, [string]$Id)
|
|
foreach($item in $Collection) {
|
|
if([string]$item.id -eq $Id) { return $item }
|
|
}
|
|
return $null
|
|
}
|
|
|
|
# Longest known collection or single-object key that prefixes the path.
|
|
# Returns @{ Key; Kind ('collection'|'single'); Rest (remaining segments) }.
|
|
function Resolve-MockGraphPath {
|
|
param([string]$Path)
|
|
$store = $script:MockGraphStore
|
|
$segments = @($Path.Split('/') | Where-Object { $_ -ne '' })
|
|
for($take = $segments.Count; $take -ge 1; $take--) {
|
|
$key = ($segments[0..($take - 1)] -join '/')
|
|
$rest = if($take -lt $segments.Count) { @($segments[$take..($segments.Count - 1)]) } else { @() }
|
|
if($store.Collections.ContainsKey($key)) { return @{ Key = $key; Kind = 'collection'; Rest = $rest } }
|
|
if($store.Singles.ContainsKey($key)) { return @{ Key = $key; Kind = 'single'; Rest = $rest } }
|
|
}
|
|
return $null
|
|
}
|
|
|
|
function Add-MockGraphExpansion {
|
|
param($Item, [string]$Expand)
|
|
if(-not $Expand) { return $Item }
|
|
foreach($clause in $Expand.Split(',')) {
|
|
$name = ($clause.Trim() -split '\(')[0].Trim()
|
|
if(-not $name) { continue }
|
|
if(-not $Item.PSObject.Properties[$name]) {
|
|
$Item | Add-Member -NotePropertyName $name -NotePropertyValue @() -Force
|
|
}
|
|
}
|
|
return $Item
|
|
}
|
|
|
|
function Invoke-MockGraphList {
|
|
param($Collection, [hashtable]$Query)
|
|
$filter = $Query['$filter']
|
|
$expand = $Query['$expand']
|
|
$top = 0
|
|
if($Query['$top']) { try { $top = [int]$Query['$top'] } catch { } }
|
|
|
|
$items = [System.Collections.Generic.List[object]]::new()
|
|
foreach($item in $Collection) {
|
|
if(-not (Test-MockGraphFilter -Item $item -Filter $filter)) { continue }
|
|
$items.Add((Add-MockGraphExpansion (Copy-MockGraphObject $item) $expand))
|
|
if($top -gt 0 -and $items.Count -ge $top) { break }
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{ value = $items.ToArray() }))
|
|
}
|
|
|
|
# Stamp the properties Graph fills in on create.
|
|
function Set-MockGraphCreatedProperties {
|
|
param($Item)
|
|
$now = [DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ")
|
|
if(-not $Item.PSObject.Properties['id'] -or -not $Item.id) {
|
|
$Item | Add-Member -NotePropertyName id -NotePropertyValue ([guid]::NewGuid().ToString()) -Force
|
|
}
|
|
foreach($name in 'createdDateTime', 'lastModifiedDateTime') {
|
|
$Item | Add-Member -NotePropertyName $name -NotePropertyValue $now -Force
|
|
}
|
|
return $Item
|
|
}
|
|
|
|
function Invoke-MockGraphCollectionRequest {
|
|
param([string]$Method, [string]$Key, [string[]]$Rest, [hashtable]$Query, $Body)
|
|
$collection = $script:MockGraphStore.Collections[$Key]
|
|
|
|
if($Rest.Count -eq 0) {
|
|
switch($Method) {
|
|
'GET' { return (Invoke-MockGraphList -Collection $collection -Query $Query) }
|
|
'POST' {
|
|
$item = Set-MockGraphCreatedProperties (Copy-MockGraphObject $Body)
|
|
$collection.Add($item)
|
|
return (New-MockGraphResult 201 (Copy-MockGraphObject $item))
|
|
}
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{}))
|
|
}
|
|
|
|
$id = $Rest[0]
|
|
$item = Get-MockGraphItem -Collection $collection -Id $id
|
|
if(-not $item) {
|
|
Write-LogDebug "Mock Graph: $Method $Key/$id - no such item"
|
|
if($Method -eq 'GET' -and $Rest.Count -gt 1) { return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @() })) }
|
|
return (New-MockGraphResult 404 ([PSCustomObject]@{ error = [PSCustomObject]@{ code = 'ResourceNotFound'; message = "Mock tenant has no $Key with id $id" } }))
|
|
}
|
|
|
|
if($Rest.Count -eq 1) {
|
|
switch($Method) {
|
|
'GET' { return (New-MockGraphResult 200 (Add-MockGraphExpansion (Copy-MockGraphObject $item) $Query['$expand'])) }
|
|
'PATCH' {
|
|
foreach($prop in $Body.PSObject.Properties) {
|
|
$item | Add-Member -NotePropertyName $prop.Name -NotePropertyValue $prop.Value -Force
|
|
}
|
|
$item | Add-Member -NotePropertyName lastModifiedDateTime -NotePropertyValue ([DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ")) -Force
|
|
return (New-MockGraphResult 200 (Copy-MockGraphObject $item))
|
|
}
|
|
'PUT' {
|
|
foreach($prop in $Body.PSObject.Properties) {
|
|
$item | Add-Member -NotePropertyName $prop.Name -NotePropertyValue $prop.Value -Force
|
|
}
|
|
return (New-MockGraphResult 200 (Copy-MockGraphObject $item))
|
|
}
|
|
'DELETE' { [void]$collection.Remove($item); return (New-MockGraphResult 204 $null) }
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{}))
|
|
}
|
|
|
|
# <collection>/<id>/<segment>: a navigation property or an action.
|
|
$segment = $Rest[1]
|
|
switch($segment) {
|
|
'assign' {
|
|
# POST .../assign { assignments: [...] } replaces the assignments.
|
|
$assignments = @()
|
|
if($Body -and $Body.PSObject.Properties['assignments']) { $assignments = @($Body.assignments) }
|
|
foreach($a in $assignments) {
|
|
if(-not $a.PSObject.Properties['id'] -or -not $a.id) { $a | Add-Member -NotePropertyName id -NotePropertyValue ([guid]::NewGuid().ToString()) -Force }
|
|
}
|
|
$item | Add-Member -NotePropertyName assignments -NotePropertyValue $assignments -Force
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{ value = (Copy-MockGraphObject $assignments) }))
|
|
}
|
|
'assignments' {
|
|
if($Method -eq 'POST') {
|
|
$existing = @()
|
|
if($item.PSObject.Properties['assignments']) { $existing = @($item.assignments) }
|
|
$new = Copy-MockGraphObject $Body
|
|
if(-not $new.PSObject.Properties['id'] -or -not $new.id) { $new | Add-Member -NotePropertyName id -NotePropertyValue ([guid]::NewGuid().ToString()) -Force }
|
|
$item | Add-Member -NotePropertyName assignments -NotePropertyValue (@($existing) + @($new)) -Force
|
|
return (New-MockGraphResult 201 (Copy-MockGraphObject $new))
|
|
}
|
|
}
|
|
}
|
|
|
|
$prop = $item.PSObject.Properties[$segment]
|
|
if($Method -eq 'GET') {
|
|
if(-not $prop) { return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @() })) }
|
|
$value = Copy-MockGraphObject $prop.Value
|
|
if($null -eq $value) { return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @() })) }
|
|
if($prop.Value -is [array] -or $prop.Value -is [System.Collections.IList]) {
|
|
$items = @($value)
|
|
if($Query['$filter']) { $items = @($items | Where-Object { Test-MockGraphFilter -Item $_ -Filter $Query['$filter'] }) }
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{ value = $items }))
|
|
}
|
|
return (New-MockGraphResult 200 $value)
|
|
}
|
|
if($Method -eq 'POST' -and $Rest.Count -eq 2) {
|
|
# Action on the item (e.g. .../updateDefinitionValues, .../createCopy): accept.
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{}))
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{}))
|
|
}
|
|
|
|
# One request in, one @{ Status; Body } out. The body is an object, not JSON.
|
|
function Resolve-MockGraphRequest {
|
|
[CmdletBinding()]
|
|
param([string]$Method, [string]$Url, $Body)
|
|
|
|
if(-not $script:MockGraphStore) { throw "Mock Graph store is not initialized" }
|
|
$Method = $Method.ToUpperInvariant()
|
|
$parts = Split-MockGraphUrl $Url
|
|
$path = $parts.Path
|
|
|
|
if($path -eq '$batch') {
|
|
$responses = [System.Collections.Generic.List[object]]::new()
|
|
foreach($request in @($Body.requests)) {
|
|
$sub = Resolve-MockGraphRequest -Method ([string]$request.method) -Url ([string]$request.url) -Body $request.body
|
|
$responses.Add([PSCustomObject]@{
|
|
id = $request.id
|
|
status = $sub.Status
|
|
headers = [PSCustomObject]@{ 'Content-Type' = 'application/json' }
|
|
body = $sub.Body
|
|
})
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{ responses = $responses.ToArray() }))
|
|
}
|
|
|
|
$resolved = Resolve-MockGraphPath $path
|
|
if(-not $resolved) {
|
|
Write-LogDebug "Mock Graph: no data for $Method $path - answering with an empty collection"
|
|
if($Method -eq 'GET') { return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @() })) }
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{}))
|
|
}
|
|
|
|
if($resolved.Kind -eq 'single') {
|
|
$obj = $script:MockGraphStore.Singles[$resolved.Key]
|
|
if($resolved.Rest.Count -eq 0) {
|
|
if($Method -eq 'PATCH') {
|
|
foreach($prop in $Body.PSObject.Properties) { $obj | Add-Member -NotePropertyName $prop.Name -NotePropertyValue $prop.Value -Force }
|
|
}
|
|
return (New-MockGraphResult 200 (Copy-MockGraphObject $obj))
|
|
}
|
|
$prop = $obj.PSObject.Properties[$resolved.Rest[0]]
|
|
if($prop) {
|
|
$value = Copy-MockGraphObject $prop.Value
|
|
if($prop.Value -is [array]) { return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @($value) })) }
|
|
return (New-MockGraphResult 200 $value)
|
|
}
|
|
return (New-MockGraphResult 200 ([PSCustomObject]@{ value = @() }))
|
|
}
|
|
|
|
return (Invoke-MockGraphCollectionRequest -Method $Method -Key $resolved.Key -Rest $resolved.Rest -Query $parts.Query -Body $Body)
|
|
}
|
|
|
|
# Shape a result like Invoke-WebRequest's response, which is what
|
|
# Invoke-MSGraphAPI reads (StatusCode / StatusDescription / Headers / Content /
|
|
# RawContentLength). A 4xx throws the way Invoke-WebRequest does, with the
|
|
# response on the exception, so the product's error handling runs unchanged
|
|
# and reports the status, error code and message of a mock failure.
|
|
function ConvertTo-MockWebResponse {
|
|
param($Result)
|
|
$json = if($null -eq $Result.Body) { "" } else { ($Result.Body | ConvertTo-Json -Depth 50 -Compress) }
|
|
$description = switch($Result.Status) { 200 { 'OK' } 201 { 'Created' } 204 { 'No Content' } 400 { 'Bad Request' } 403 { 'Forbidden' } 404 { 'Not Found' } default { 'OK' } }
|
|
$response = [PSCustomObject]@{
|
|
StatusCode = [int]$Result.Status
|
|
StatusDescription = $description
|
|
Headers = @{ 'Content-Type' = 'application/json'; 'request-id' = [guid]::NewGuid().ToString() }
|
|
Content = $json
|
|
RawContentLength = [long][System.Text.Encoding]::UTF8.GetByteCount($json)
|
|
}
|
|
if($Result.Status -ge 400) {
|
|
# Read-MSGraphErrorResponseContent takes the body from
|
|
# Response.GetResponseStream(), as it does for an HttpWebResponse.
|
|
$response | Add-Member -NotePropertyName ContentBytes -NotePropertyValue ([System.Text.Encoding]::UTF8.GetBytes($json))
|
|
$response | Add-Member -MemberType ScriptMethod -Name GetResponseStream -Value { [System.IO.MemoryStream]::new([byte[]]$this.ContentBytes) }
|
|
throw [MockGraphResponseException]::new("The remote server returned an error: ($($Result.Status)) $description.", $response)
|
|
}
|
|
return $response
|
|
}
|
|
|
|
# Entry point used by AuthenticationMock.InvokeWebRequest.
|
|
function Invoke-MockGraphRequest {
|
|
[CmdletBinding()]
|
|
param([string]$Url, [string]$Method, $Body)
|
|
|
|
$bodyObject = $null
|
|
if($null -ne $Body) {
|
|
if($Body -is [string]) {
|
|
if($Body.Trim()) { try { $bodyObject = $Body | ConvertFrom-Json } catch { $bodyObject = $null } }
|
|
}
|
|
elseif($Body -is [byte[]]) {
|
|
try { $bodyObject = [System.Text.Encoding]::UTF8.GetString($Body) | ConvertFrom-Json } catch { $bodyObject = $null }
|
|
}
|
|
else { $bodyObject = $Body }
|
|
}
|
|
$result = Resolve-MockGraphRequest -Method $Method -Url $Url -Body $bodyObject
|
|
return (ConvertTo-MockWebResponse $result)
|
|
}
|