fix dism usage

Author: Steve Lee (POWERSHELL HE/HIM) (from Dev Box)

resources/dism_dsc/locales/en-us.toml

@@ -33,6 +33,7 @@ failedParseInput = "Failed to parse input: %{err}"
 capabilitiesArrayEmpty = "Capabilities array cannot be empty for set operation"
 nameRequired = "name is required for set operation"
 stateRequired = "state is required for set operation"
+capabilityNotFound = "Capability '%{name}' was not found on this system"
 unsupportedDesiredState = "Unsupported desired state '%{state}'. Supported states for set are: Installed, NotPresent"
 failedSerializeOutput = "Failed to serialize output: %{err}"
 

resources/dism_dsc/src/feature_on_demand/get.rs

@@ -33,12 +33,12 @@ pub fn handle_get(input: &str) -> Result<String, String> {
         } else {
             FeatureOnDemandInfo {
                 name: Some(raw.name),
-                exist: None,
                 state: CapabilityState::from_dism(raw.state),
                 display_name: Some(raw.display_name),
                 description: Some(raw.description),
                 download_size: Some(raw.download_size),
                 install_size: Some(raw.install_size),
+                ..FeatureOnDemandInfo::default()
             }
         };
         results.push(info);

resources/dism_dsc/src/feature_on_demand/set.rs

@@ -32,11 +32,19 @@ pub fn handle_set(input: &str) -> Result<String, String> {
             .ok_or_else(|| t!("fod_set.stateRequired").to_string())?;
 
         let current = session.get_capability_info(name)?;
+
+        if current.unknown {
+            return Err(t!("fod_set.capabilityNotFound", name = name).to_string());
+        }
+
         let current_state = CapabilityState::from_dism(current.state);
 
         let needs_reboot = match desired_state {
             CapabilityState::Installed => {
-                session.add_capability(name)?
+                match current_state {
+                    Some(CapabilityState::Installed) => false,
+                    _ => session.add_capability(name)?,
+                }
             }
             CapabilityState::NotPresent => {
                 match current_state {
@@ -58,12 +66,12 @@ pub fn handle_set(input: &str) -> Result<String, String> {
         let raw = session.get_capability_info(name)?;
         let info = FeatureOnDemandInfo {
             name: Some(raw.name),
-            exist: None,
             state: CapabilityState::from_dism(raw.state),
             display_name: Some(raw.display_name),
             description: Some(raw.description),
             download_size: Some(raw.download_size),
             install_size: Some(raw.install_size),
+            ..FeatureOnDemandInfo::default()
         };
         results.push(info);
     }

resources/dism_dsc/src/optional_feature/dism.rs

@@ -25,13 +25,13 @@ unsafe extern "system" {
     ) -> *mut c_void;
 }
 
-#[repr(C, packed)]
+#[repr(C, packed(4))]
 struct DismFeature {
     feature_name: *const u16,
     state: i32,
 }
 
-#[repr(C, packed)]
+#[repr(C, packed(4))]
 struct DismFeatureInfo {
     feature_name: *const u16,
     state: i32,
@@ -42,13 +42,13 @@ struct DismFeatureInfo {
     custom_property_count: u32,
 }
 
-#[repr(C, packed)]
+#[repr(C, packed(4))]
 struct DismCapability {
     name: *const u16,
     state: i32,
 }
 
-#[repr(C, packed)]
+#[repr(C, packed(4))]
 struct DismCapabilityDetail {
     name: *const u16,
     state: i32,

resources/dism_dsc/tests/featureOnDemand_export.tests.ps1

@@ -128,6 +128,14 @@ Describe 'Microsoft.Windows/FeatureOnDemandList - export operation' -Skip:(!$IsW
         $capabilities.Count | Should -Be 0
     }
 
+    It 'returns empty results for empty capabilities array input' -Skip:(!$isElevated) {
+        $inputJson = '{"capabilities":[]}'
+        $output = dsc resource export -r Microsoft.Windows/FeatureOnDemandList -i $inputJson | ConvertFrom-Json
+        $LASTEXITCODE | Should -Be 0
+        $capabilities = $output.resources[0].properties.capabilities
+        $capabilities.Count | Should -Be 0
+    }
+
     It 'returns complete capability properties when full-info filter is used' -Skip:(!$isElevated) {
         $inputJson = '{"capabilities":[{"name":"' + $knownCapabilityNameOne + '","displayName":"*"}]}'
         $output = dsc resource export -r Microsoft.Windows/FeatureOnDemandList -i $inputJson | ConvertFrom-Json

resources/dism_dsc/tests/featureOnDemand_get.tests.ps1

@@ -57,12 +57,20 @@ Describe 'Microsoft.Windows/FeatureOnDemandList - get operation' -Skip:(!$IsWind
         $inputJson = '{"capabilities":[{"state":"Installed"}]}'
         $testError = & { dsc resource get -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'name is required'
     }
 
     It 'returns error when capabilities array is empty' -Skip:(!$isElevated) {
         $inputJson = '{"capabilities":[]}'
         $testError = & { dsc resource get -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'cannot be empty'
+    }
+
+    It 'returns error for malformed JSON input' -Skip:(!$isElevated) {
+        $inputJson = '{"capabilities":[{invalid'
+        $testError = & { dsc resource get -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
+        $LASTEXITCODE | Should -Not -Be 0
     }
 
     It 'returns _exist false for a non-existent capability name' -Skip:(!$isElevated) {

resources/dism_dsc/tests/featureOnDemand_set.tests.ps1

@@ -11,80 +11,120 @@ Describe 'Microsoft.Windows/FeatureOnDemandList - set operation' -Skip:(!$IsWind
         }
     }
 
+    BeforeAll {
+        # Dynamically discover capability names instead of hardcoding
+        $dismOutput = & dism /Online /Get-Capabilities /Format:Table /English 2>&1
+        if ($LASTEXITCODE -ne 0) {
+            throw "Failed to get capabilities using dism: $dismOutput"
+        }
+        $installedMatches = $dismOutput | Select-String -Pattern '^\s*(\S+)\s+\|\s+Installed\s*$'
+        $notPresentMatches = $dismOutput | Select-String -Pattern '^\s*(\S+)\s+\|\s+Not Present\s*$'
+        if (-not $installedMatches -or -not $notPresentMatches) {
+            throw "Failed to find both installed and not-present capabilities in DISM output.`nOutput:`n$dismOutput"
+        }
+        $knownInstalledCapability = $installedMatches[0].Matches[0].Groups[1].Value
+        $knownNotPresentCapability = $notPresentMatches[0].Matches[0].Groups[1].Value
+
+        # Record initial states for cleanup
+        $script:initialInstalledState = 'Installed'
+        $script:initialNotPresentState = 'NotPresent'
+    }
+
+    AfterAll {
+        # Restore capabilities to their original states
+        if ($knownInstalledCapability) {
+            $restoreJson = '{"capabilities":[{"name":"' + $knownInstalledCapability + '","state":"' + $script:initialInstalledState + '"}]}'
+            dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $restoreJson 2>&1 | Out-Null
+        }
+        if ($knownNotPresentCapability) {
+            $restoreJson = '{"capabilities":[{"name":"' + $knownNotPresentCapability + '","state":"' + $script:initialNotPresentState + '"}]}'
+            dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $restoreJson 2>&1 | Out-Null
+        }
+    }
+
     It 'returns error when name is missing' -Skip:(!$isElevated) {
         $inputJson = '{"capabilities":[{"state":"Installed"}]}'
         $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'name is required'
     }
 
     It 'returns error when state is missing' -Skip:(!$isElevated) {
-        $inputJson = '{"capabilities":[{"name":"Language.Basic~~~en-US~0.0.1.0"}]}'
+        $inputJson = '{"capabilities":[{"name":"' + $knownInstalledCapability + '"}]}'
         $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'state is required'
     }
 
     It 'returns error when capabilities array is empty' -Skip:(!$isElevated) {
         $inputJson = '{"capabilities":[]}'
         $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'cannot be empty'
     }
 
     It 'returns error for unsupported desired state' -Skip:(!$isElevated) {
-        $inputJson = '{"capabilities":[{"name":"Language.Basic~~~en-US~0.0.1.0","state":"Staged"}]}'
+        $inputJson = '{"capabilities":[{"name":"' + $knownInstalledCapability + '","state":"Staged"}]}'
+        $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
+        $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'Unsupported desired state'
+    }
+
+    It 'returns error for malformed JSON input' -Skip:(!$isElevated) {
+        $inputJson = '{"capabilities":[{invalid'
+        $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
+        $LASTEXITCODE | Should -Not -Be 0
+    }
+
+    It 'returns error when installing a non-existent capability' -Skip:(!$isElevated) {
+        $inputJson = '{"capabilities":[{"name":"NonExistent-Capability-1234567890","state":"Installed"}]}'
         $testError = & { dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson 2>&1 }
         $LASTEXITCODE | Should -Not -Be 0
+        "$testError" | Should -Match 'not found'
     }
 
-    It 'can install a capability and returns updated state' -Skip:(!$isElevated) {
-        # Use a capability known to exist on most Windows systems
-        $inputJson = '{"capabilities":[{"name":"Language.Basic~~~en-US~0.0.1.0","state":"Installed"}]}'
+    It 'can install a capability and returns updated state' -Skip:(!$isElevated) -Tag 'Mutating' {
+        $inputJson = '{"capabilities":[{"name":"' + $knownInstalledCapability + '","state":"Installed"}]}'
         $output = dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
         $output.afterState.capabilities | Should -Not -BeNullOrEmpty
         $output.afterState.capabilities.Count | Should -Be 1
         $cap = $output.afterState.capabilities[0]
-        $cap.name | Should -BeExactly 'Language.Basic~~~en-US~0.0.1.0'
+        $cap.name | Should -BeExactly $knownInstalledCapability
         $cap.state | Should -BeIn @('Installed', 'InstallPending')
         $cap.displayName | Should -Not -BeNullOrEmpty
     }
 
-    It 'can remove a capability and returns updated state' -Skip:(!$isElevated) {
-        $inputJson = '{"capabilities":[{"name":"Language.Basic~~~en-US~0.0.1.0","state":"NotPresent"}]}'
+    It 'can remove a capability and returns updated state' -Skip:(!$isElevated) -Tag 'Mutating' {
+        $inputJson = '{"capabilities":[{"name":"' + $knownNotPresentCapability + '","state":"NotPresent"}]}'
         $output = dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $inputJson | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
         $output.afterState.capabilities | Should -Not -BeNullOrEmpty
         $output.afterState.capabilities.Count | Should -Be 1
         $cap = $output.afterState.capabilities[0]
-        $cap.name | Should -BeExactly 'Language.Basic~~~en-US~0.0.1.0'
-        # Installed is accepted because some base capabilities cannot be removed by DISM
-        $cap.state | Should -BeIn @('NotPresent', 'Removed', 'UninstallPending', 'Staged', 'Installed')
+        $cap.name | Should -BeExactly $knownNotPresentCapability
+        $cap.state | Should -BeIn @('NotPresent', 'Removed', 'UninstallPending', 'Staged')
     }
 
-    It 'sets state to Installed for an already installed capability' -Skip:(!$isElevated) {
-        # First ensure the capability is installed
-        $installJson = '{"capabilities":[{"name":"Language.Basic~~~en-US~0.0.1.0","state":"Installed"}]}'
-        dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $installJson | Out-Null
-        $LASTEXITCODE | Should -Be 0
-
-        # Set Installed again — should succeed idempotently
+    It 'sets state to Installed for an already installed capability' -Skip:(!$isElevated) -Tag 'Mutating' {
+        # Set Installed on an already-installed capability — should succeed idempotently
+        $installJson = '{"capabilities":[{"name":"' + $knownInstalledCapability + '","state":"Installed"}]}'
         $output = dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $installJson | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
         $output.afterState.capabilities | Should -Not -BeNullOrEmpty
         $cap = $output.afterState.capabilities[0]
-        $cap.name | Should -BeExactly 'Language.Basic~~~en-US~0.0.1.0'
+        $cap.name | Should -BeExactly $knownInstalledCapability
         $cap.state | Should -Be 'Installed'
     }
 
-    It 'sets state to NotPresent for an already not-present capability' -Skip:(!$isElevated) {
-        # Use a capability name that does not exist on the system, so it is already NotPresent
-        $notPresentJson = '{"capabilities":[{"name":"Test.NonExistent.Capability~~~0.0.1.0","state":"NotPresent"}]}'
-
-        # Set NotPresent — should succeed idempotently since it is already not present
+    It 'sets state to NotPresent for an already not-present capability' -Skip:(!$isElevated) -Tag 'Mutating' {
+        # Set NotPresent on an already not-present capability — should succeed idempotently
+        $notPresentJson = '{"capabilities":[{"name":"' + $knownNotPresentCapability + '","state":"NotPresent"}]}'
         $output = dsc resource set -r Microsoft.Windows/FeatureOnDemandList -i $notPresentJson | ConvertFrom-Json
         $LASTEXITCODE | Should -Be 0
         $output.afterState.capabilities | Should -Not -BeNullOrEmpty
         $cap = $output.afterState.capabilities[0]
-        $cap.name | Should -BeExactly 'Test.NonExistent.Capability~~~0.0.1.0'
+        $cap.name | Should -BeExactly $knownNotPresentCapability
         $cap.state | Should -BeIn @('NotPresent', 'Removed', 'Staged')
 
         # Set NotPresent again — should still succeed idempotently